List of resource type IDs

I have not included other Open Source modules or the OAMP suite. I may update this list later.

A short background on categories

Categories are a built-in content relation in OpenCms and allow files in the VFS to be assigned one or more topics/keywords/whatever. They can often be used as a replacement feature for siblings which are mostly misunderstood by users without a technical background. For example consider the typical example of a news site. You have a folder structure for your articles which could be the following way:

/articles/2008/12-24-merry-christmas.html
/articles/2009/09-01-new-site.html
/articles/2009/10-02-a-great-article.html

You now want to categorize the articles into topics so you would create another folder structure:

/topic/must-read
/topic/technical

The sibling-way would be to create a sibling (put simply: an automatically updating copy) of the articles in the desired topic folder. While this is a working solution it’s counterintuitive to most users. OpenCms 7 introduced the long awaited Content Relation Engine (CRE) including a default relation called categories. Similar to the sibling solution a category is effectively a folder but instead of creating it anywhere in the filesystem it’s created in the root site (“/”) under /system/categories/. Users can now assign categories to VFS files using the context-menu entry Relations -> Assign Categories. This is a much easier approach although it has one caveat: Categories are globally defined in the /system/ folder and can therefore only be created by users with access to the root site and can not be specified on a per site or even per folder basis. This can cause problems in multisite environments.

Decentralization to the rescue

With OpenCms 7.5 this limitation is finally gone. You can now define categories on a per-site and even per-folder basis. Simply create a folder named _categories in the folder where you want the categories to be available. Then create new folders inside this folder to define categories. The categories are available in the parent folder of the _categories-folder and all subfolders. They also cascade down. Example:

/de/_categories/
/de/_categories/hot-topic
/de/_categories/support
/de/news/_categories/
/de/news/_categories/marketing
/de/news/_categories/development

Inside the /de/ folder the categories hot-topic and support are available. Inside /de/news/ the categories hot-topic, support, marketing and development are available.

This feature should easily help you to get your content structured more nicely. Speaking from experience it is crucial to create an evolveable content structure upfront so your editors as well as visitors and search engines get the most out of your site.

See also:

• Presentation from Michael Moossen about the CRE at OpenCms Days 2008
• A guide to good URI design

Example: I want to login the user “foo” of the OU “/germany/marketing“. Simple specify the String “/germany/marketing/foo” as a username and you’re all set.

This is the continued report from the OpenCms Days 2009. If you haven’t read the first part you might as well read it first.

The second day started with the keynote of Joel Tosi and I think this was one of the best talks of the conference (although his question totally took me by surprise since I had had no coffee yet).
Joel took a very critical view on enterprise software and support claims and explained some of the benefits they get from OpenCms at the CME.
I especially liked that he presented very concrete information of implementation and business (numbers & figures)  and also think taking the seriousness out of some enterprise label was really good.I saw many people smiling knowingly throughout the whole presentation. You rarely have a talk which is informative and also entertaining.

After the keynote I watched a presentation by Pedro del Valle and Pedro Antón Alonso about the relaunch of spain.info and the creation of a tourist information portal for Spain (portals where all over the place at this conference). I personally didn’t expect to get very much out of this talk but I gladly admit that I could not have been more wrong.
The presented solution showed some integrations which I had already developed (like the Google maps integration) and I was relieved that they took a similar route on implementation. I liked their argument that it’s best to put the information where the consumer is. They e.g. plan to publish the videos out to a dedicated YouTube channel. This is something I always suggested to my customers but often had a hard time selling. Mention this project will hopefully convince other people to take this route.
There were a lot of questions afterwards and I think this was also one of the best talks of the conference.

After this talk I unfortunately started coding for the scripting integration on my laptop (sorry to all the speakers who saw this – This was not because I wasn’t interested but I somehow got into the flow and then wanted to push back my changes to sourceforge. You hopefully know this feeling and I hereby apologize). I might have missed some content in the following presentations.

Georgi Naplatanov presented the JPA driver for OpenCms and although there was confusion because of some figures, he has done a great job. There seemed to be some performance problems with JPA/OpenJPA and MySQL but Florian Hopf, Claus Priisholm and Dan Liliedahl all mentioned that these might be gone if one uses Hibernate instead of OpenJPA. I hope someone is trying this out.
There was also the question of using this driver to run OpenCms on Google App Engine. So if anyone of the asking people is reading this: Please have a look at my Blog post. I think having JPA at hand is a big win for OpenCms. Especially if you plan on writing modules which introduce new database tables. Doing so with the current drivers is especially hard since you have to target all supported databases manually. At least if you want to be portable.

In the third session Alejandro Alves showcased some modules the Spanish OpenCms community has developed. I was impressed by the sheer amount of the modules. Especially the forum seems big.
I like that he obviously used a real project for demoing the modules. This gave a good impression of the solutions other people develop with OpenCms. Often discussions tend to be very abstract and seeing some real world examples helps to get a feel for the solution. It occurred to me that there’s a lot of development going on in the Spanish world. I wish I would speak the language.

The last session of the conference I watched was done by Michael Emmerich about the Alkacon OAMP modules. I’ve not used the OAMP modules a lot so it was a really great opportunity to see everything in action and get some insider tips on how to customize them. Michael sure did a great job with this.
I was most impressed by the DocCenter module because this was something I had to develop for a customer before and spent a lot time doing so (If it had just been open sourced by then…  – my solution was a lot worse).

There was a panel discussion at the end but I got sidetracked by trying to recover my sourceforge login. The questions were interesting but unfortunately it seemed that everyone (including myself) was already tired and so no real audience interaction came up.
Maybe I should have saved some questions for this event because I already asked all the panel members everything that interested me during the first two days and there seemed no point in doing so again.
It was interesting that the point of documentation (one of last years hot topics) didn’t came up very often. I think we can give credits to Dan who wrote a fantastic book about OpenCms 7 development and all the people who contributed to the wiki. I guess the documentation issue has been solved for the most part.
The lack of a large set of available modules was also mentioned but it seemed to me that there’s a lot in the pipeline and maybe just needs to be presented better. It also feels like the module space is a bit fragmented. Often companies put their modules out under their own namespace which makes it relatively unattractive for other companies to contribute. I think having something similar to the OAMP suite but on sourceforge or google code would help. Companies could still be mentioned as a sponsor and therefore get some publicity out of it.
What might also be nice would be a higher level template/content framework to help people getting up to speed more quickly. But this might be coming with the advanced direct edit functionality which is planned for version 8 and was explained in Alexanders keynote.

To sum up everything: I think the OpenCms Days 2009 were great! I had a lot of fun although I’m very exhausted by the time of writing this draft. I met a lot of extremely nice and fun people. Thank you all for the good time. I’m looking forward to seeing you again. I think I missed to say a proper goodbye to some of you. This was just because I got somehow lost on my way out and then everyone seemed to be gone already.

See you in 2010.

The JSP has no interface since I mainly use it for development. Simply create a JSP somewhere in the OpenCms VFS and then open the file via the browser. E.g.:

“http://workplace.com/system/createzip?source=/system/modules/foo&filename=foo-module.zip”

The source parameter specifies which directory to zip up and the filename parameter which filename to use for the generated file. You can only zip up resources with a total size of 10 megabytes. This is mainly to prevent OutOfMemory errors to happen. You can easily increase the size by altering the variable maxSourceSize to any value you need.

If you find any bugs or want to give feedback simply leave a comment or send me an email.

<%@page import="org.opencms.util.*,
                org.opencms.jsp.*,
                org.opencms.file.*,
                java.util.*,
                java.io.*,
                java.util.zip.*
" %><%

// Maximum filesize to prevent OutOfMemory errors
long maxSourceSize = 1024*1024*10; // 10 Megabytes

// The filename to use as output
String filename = request.getParameter("filename");

// The directory to zip
String source = request.getParameter("source");

if (CmsStringUtil.isEmpty(filename) || CmsStringUtil.isEmpty(source )) {
  // Ensure that all parameters are given
  throw new IllegalArgumentException("Please specify the 'source' and the 'filename' parameter");
}

if (!source.endsWith("/")) { source = source + "/"; }

CmsJspActionElement cmsa = new CmsJspActionElement(pageContext,request,response);
CmsObject cmso = cmsa.getCmsObject();
List zipResources = new ArrayList();

// Collect all the resources
CmsResource sourceResource = cmso.readResource(source);
if (!sourceResource.isFolder()) {
  throw new IllegalArgumentException("Please specify a folder to zip");
}
List cmsResources = cmso.readResources(source,CmsResourceFilter.DEFAULT);
for (Iterator i = cmsResources.iterator(); i.hasNext();) {
  zipResources.add(i.next());
}

// Create the zip file
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ZipOutputStream zipfile = new ZipOutputStream(bos);

long currentSize = 0;
for (Iterator i = zipResources.iterator(); i.hasNext(); ) {
  CmsResource res = (CmsResource) i.next();

  currentSize += res.getLength();
  if (currentSize > maxSourceSize) {
    // Ensure that we don't zip up too much
    throw new RuntimeException("Source size is bigger than: " + (maxSourceSize/1024) + " kilobytes");
  }

  String sourcePath = cmso.getRequestContext().getSitePath(res);
  String targetPath = sourcePath;
  if (targetPath.startsWith(source)) {
    targetPath = targetPath.substring(source.length());
  }

  //out.println("Zipping " + sourcePath + " as " + targetPath + "<br/>");
  if (res.isFile()) {
  ZipEntry zipentry = new ZipEntry(targetPath);
  zipfile.putNextEntry(zipentry);
      CmsFile file = cmso.readFile(res);
      zipfile.write(file.getContents(),0,file.getLength());
  }
}

zipfile.close();
byte[] content = bos.toByteArray();

response.setContentType("application/octet-stream");
response.setContentLength((int)content.length);
response.setHeader("Content-Disposition", "attachment; filename=\"" + filename + "\"" );

response.getOutputStream().write(content,0,content.length);
response.getOutputStream().flush();

%>

The problem with OpenCms and App Engine is that the applications on App Engine run in a restricted sandbox which limits what you can do in terms of Java API functionality. There’s also a JRE whitelist which limits the classes you can access in your application. If you look at the scalability model promoted by App Engine these limitations make a lot of sense but unfortunately they make running OpenCms on there nearly impossible. You can find a detailed description of the App Engine runtime at Google code. The main problems are:

• No filesystem access: OpenCms uses the filesystem for some very important tasks:
  • The JSP files are exported into the WEB-INF directory to be executable. This means there could be no dynamic updates or adds of JSP files through the workplace.
  • The configuration is stored in the filesystem and dynamically updated if e.g. the search configuration is updated or a module is installed. The configuration would have to be stored in the database.
  • The search index is stored in the filesystem. This could be circumvented if a Lucene database store like the one shipped with Compass is used. Nevertheless this would have to be implemented.
• No threading: OpenCms makes uses of threading for scheduled tasks, publishing and other tasks. Since App Engine doesn’t allow threads this would have to be implemented otherwise.
• Response-Time-Limit: App Engine imposes a time limit to handle request on the application. Escpecially the publishing mechanism in OpenCms causes very long response times. These parts would have to be rewritten.
• Persistent data has to be stored in the datastore: OpenCms uses an in memory HashMap to store the locking information (file locks). This makes it difficult to cluster OpenCms and also limits the use in Googles App Engine. This also affects the Flex-Cache: Publishing events would have to be propagated and I’m not sure if this would work with App Engine (comments are very welcome on this point).

I had a short talk with Alexander about this topic and it at least seemed to us that making OpenCms run on the App Engine would be an enormous task and is currently not worth doing without excessive sponsoring.

After two days of information overflow the OpenCms days 2009 are finally over. I think they were a success and personally got a lot value out of them.

We had a small get together on Sunday evening with a nice diner and some Kölsch. I think it’s always nice to meet some people before the conference so you can already connect to some people. We stayed out rather long and I was back at the hotel around 3:00 AM, but it was a lot of fun. I had many interesting talks and met a lot of very nice people. If you’re thinking of attending the OpenCms Days 2010, I would really recommend to come on sunday evening so you don’t miss this event.

The first day started with a short welcome and Alexander Kandziors keynote. I enjoyed the keynote a lot and I liked that Alex actually presented the new features and not only talked about them. I haven’t had time to play with the 7.5 version (which was released on the same day – I guess a case of conference driven development ) but it sure looks very promising. The announcement of the workflow functionality in version 8 caused some amusement and I think it has become a running gag over the years.
But to be fair: I can understand that Alkacon can’t develop the feature without proper sponsoring. It is a big project and therefore needs to be well funded. I personally don’t think it is really important feature-wise but more a point to survive checklist driven evaluation. Most of the people I talked to don’t seem to have real use cases for it.
The announcement of the scripting support surprised me a bit (positively) but I’m looking forward to working together with Alkacon. I had a short talk with Alex about it on the last day and I’m confident that we can get something done. The conference actually inspired me to commit some changes to my module but I will blog about these on another day.

My second session was about the new galleries and the advanced widget configuration. It was presented by Andreas Zahner and I think he did a great job of pointing out some lesser known features. I also liked that they are using JSON for the widget configuration and the demonstration of the decentralized categories caused a lot of people to grab their notebook and a pen. The new galleries looked very nice and I am very fond of the tab feature for the xmlcontent editor.

The next session was Andy Savin about the usage of OpenCms at the university of Bath. I enjoyed this session a lot even despite the fact that it was placed in the business track . Andy explained their migration path to OpenCms including the evaluation and presented some of the new features they developed. For example using macros in the HTML editor to automatically insert address information.
After the session I walked up to Andy and asked him if they use caching for the rendered content because I had done some similar functionality and couldn’t get caching to work. His denial really relieved me.
I also liked his argumentation that using a single (configurable) template is often better than many templates with small differences. I share this viewpoint and agree wholeheartedly.

After a short break Dan Liliedahl explained how they integrated Liferay and OpenCms. I was looking forward to this talk because I enjoyed Dan’s talk at the OpenCms Days 2008 a lot. I like his calm and professional style of presenting. You can tell that he has done a lot of presentations before. He showed how they developed a SOAP webservice to let Liferay access the OpenCms VFS via HTTP. He also presented how the content was prepared to be easily themed by liferays theming system.
It struck me that many people have developed some kind of remote access to the VFS (mostly via webservices) and that this would probably be something to develop a module for (which I think Dan wants to do). I think the webdav servlet could deliver something like a REST (which seems to be in everybodies mouth right now) based interface to the OpenCms VFS but it seemed to me that no one is really using the webdav feature. Also it would be nice to have some kind of a JSON interface to the content.
At lunch Dan explained this solution in more detail and now I’m looking forward to his module. It seems to be a trend to use OpenCms as a content repository nowadays. This was also reflected in a short poll Alex did to find out if OpenCms should either support JSR-170 or CMIS (which I had never heard of) in the future. It seems to me that CMIS is still in an early stage but already has a lot of important vendors in the process. The fact that it’s not tied to the Java language is also a nice bonus. This could allow good integration with other web frontends (for example PHP based ones). I think it is an option that should be seriously considered.

The last talk of the first day was about the IKS project of the European Union in which OpenCms/Alkacon participate. Andreas Gruber seemed very knowledgeable and explained the reasoning and structure of the IKS project and their concept of a complete stack for the semantic web.
Although I already had some experience with RDF/OWL and microformats I had a hard time following the first part because it was relatively abstract. I think this may well be because the project is still in the requirements gathering phase and therefore had no concrete components to showcase. The second part when he presented the microformats by example and got down to the technical stuff. I was finally able to get the whole picture.
One interesting thing he mentioned afterwards was the eventual development of components to process an existing corpus of content and annotating it automatically with semantic information (like finding addresses or names in plain text/html and marking them up). If the project is successful it will be very useful for content management and the semantic web movement in the long run. I still believe it’s hard to convince the casual content creator of the value of semantic web and helping him to do so correctly. But I think the project is looking into this direction also.

The conference dinner in the evening was a nice opportunity to talk to some people and find out that many people are facing the same problems as myself. This is something I really enjoyed throughout the whole conference. There was no marketing show going on and people seemed to be very honest about their development. I personally often get fooled by self confident blog posts or marketing based presentation and come to the believe that I’m the only one having problems understanding certain things or making mistakes. Hearing that others are struggling too is always very comforting. For me this meta-information is one of the most valuable things because it is helping me to understand where I’m standing professionally.

By usage of the property folders.available (you might have to define it first) on a template you can specify a list of comma seperated folders in which the template is available (in the dropdown).

Unfortunately this property works only on file level and can not be inherited via the folder hierarchy. Also it does not provide a secure solution since the template can always be set via the advanced property dialog.

But you never know when a feature could come in handy.

Day 1

Slot 1

Advanced XML Content & Widget Configuration

Andreas is doing a session about XML Content configuration and some new features in the 7.5 series. While the title sounded extremely boring to me (sorry Andreas) the abstract convinced me that I have to see this session. I know Andreas is a real OpenCms professional so I expect it to be a great session. I really want to see this session now.

Slot 2

I really don’t know which session I want to see more. The SAP NetWeaver integration looks pretty advanced and interesting but since I’m not an SAP-person I don’t know how much I can get out of it. I remember meeting Andy Savin (University of Bath: Boldly going where others fear to tread…) last year and he told me he was looking forward to my session (which I found very encouraging). We also talked a bit about how they use OpenCms at the university. It all sounded really interesting so I think I will propably watch this session.

Slot 3

Integrating OpenCms with Liferay Portal Server

I met Dan last year and remember him as an extremely friendly and professional person. I’m looking forward to meeting him again. I enjoyed his session last year a lot and will certainly watch this one too. The topic looks very promising since OpenCms and Liferay seem like a perfect match. Can’t wait to see it.

Slot 4

The Interactive Knowledge Stack (IKS) Project and OpenCms

The semantic web is something I was always interested in. I really don’t know anything about IKS but it sounds very interesting to me. I thought about integrating RDF based metadata into OpenCms before but never had the time to implement it. I think this is going to be very interesting.

To sum up it all up: To me the OpenCms Days 2009 look very promising. I hope I will see a few familiar faces and I’m looking forward to meeting new people.

Prerequisites

• OpenCms 7 (already installed)
• Apache HTTPD 2.2 with mod_proxy_ajp
• Apache Tomcat 5.5+

Goal of the setup

• Dynamic content served from http://www.yourdomain.com/
• Static content served from http://www.yourdomain.com/opencms/export/

Steps to perform

Configure Tomcat

As described in the Howto you have to add the emptySessionPath=”true” attribute to the Tomcat AJP Connector in the server.xml:

<Connector emptySessionPath="true" port="8009" protocol="AJP/1.3" />

Configure OpenCms

You have to modify the opencms-importexport.xml configuration file. But beware the <rfs-prefix> doesn’t need changing anymore. In fact: Things won’t work if you change it the old way. These are the settings you want.

       <rfs-prefix>${CONTEXT_NAME}/export</rfs-prefix>
       <vfs-prefix></vfs-prefix>

Don’t forget to restart OpenCms.

Configure Apache HTTPD

Since the AJP Connector is now integrated in mod_proxy you don’t need the (stupid) rewrite rules anymore. I also got rid of the fact that static content is served from Apache. This has several reasons:

1. The new Tomcat is fast enough to serve static content itself. Espcecially with the NIO / APR Connector.
2. If you ever want to move the Tomcat to a different machine and use Apache HTTPD as a simple load balancer things get a lot easier if Apache doesn’t need access to the web application files.

Here’s an example virtual host:

<VirtualHost *:80>

  ServerName yourdomain.com
  DocumentRoot /some/directory

  <Proxy ajp://localhost:8009*>
     Allow from all
  </Proxy>

  ProxyPass        /opencms/   ajp://localhost:8009/opencms/
  ProxyPassReverse /opencms/   ajp://localhost:8009/opencms/

  ProxyPass /          ajp://localhost:8009/opencms/opencms/
  ProxyPassReverse /   ajp://localhost:8009/opencms/opencms/

</VirtualHost>

This is it. Don’t hesitate to ask questions.