Today, while talking with a dotCMS support agent, he made us aware that Java Service Wrapper that dotCMS uses to let you install dotCMS as a service in windows is a 32bit application and as such only allows windows to access 4Gb of memory.  On top of this, the 64bit windows version of this third-party application is not freely available.  The Java Service Wrapper that ships with dotCMS is developed by a company called Tanuki Software.  Here is a link to the software page:  http://wrapper.tanukisoftware.com/doc/english/download.jsp

If you scroll down to the bottom of the page you will note note #2:

*2: 64-bit Windows versions of the Java Service Wrapper are not currently being made available in the Community Edition.

The Community Edition is what dotCMS ships with.  Moral of the story, if you are using dotCMS in windows and want to access more than 4Gb or RAM, you need to purchase a Standard Version License from Tanuki.  I’ll post more after we’ve made the upgrade.

I will be missing the first session today  But stay tuned at 11:15 for updates from the Plugins Session.

Last night we decided to head to the 8 oz Burger for dinner.  There are not many Burger Joints I would feel comfortable getting a raw burger at, but this place was top notch.  Very good burgers.

9:30 – Surprise – I did get to attend the first session – Super Widget

• Maria is presenting and they are setting everything up still
• “Planning for flexible and reusable pulls”
• Arnaud is presenting as well
• Purpose of a widget
  • Minimize redundancy
  • Facilitate pulls for content editors
  • Permissioning
    • Widgets are Structures which have granular permissions
    • It is the admin’s job to make sure people can’t screw things up
• Common Uses
  • Content listing
  • Detail Pages
  • Random Pulls
  • UI for a Macro
• Widgets Overview
  • Can be added on any container
  • Parameters – fields on widget structure
  • Widget Code – Velocity code to be executed
• Simple Widget -vs- Custom Widgets
  • Simple:  Just a title and the code – used forms, detail page, sitemap
  • Custom:  Parameters – used for pulls, reusable
• When to create a widget
  • Rule of Thumb 1 – one widget structure per content structure
  • What Content do you need? -> create the structure (ex. news structure)
  • How does this need displayed? -> create the widget (ex. news listing widget)
  • Checklist for creating a widget
    • Wireframes as a foundation for structures
    • Identification of *all* dynamic pulls
    • Definition of Parameters
• Arnaud is showing several examples, you can see some of these on the demo site:  http://demo.dotcms.org/
• widget structure -vs- widget content
  • You create the structures and for each structure you can create the content items for your users to use.
• Arnaud is wrapping up time for questions
• Maria is showing us — when users change their minds — give them the parameters to change their minds.  If they decide they want the image bigger/smaller then they can change the parameters, if this was a macro or just a contentlet you would be modifying the code.
• Have a show checkbox for each of the fields so if they don’t want an image they can turn them off
• If you upgraded from pre-widgets then you didn’t get things like the simple widget and the pre built custom widgets.  You will get these in 1.9 when you upgrade.  Or if you want to see them now you can always copy from the demo site or deploy a starter site of your own,
• If you started post-widgets then you get those things by default to start with
• field names:  make them useful for your user not you.  don’t do fields like class names and so forth, just make a radio narrow/wide
• Maria is demoing creating a structure
• Now she is showing editing one to add a sort by field
  • Have the content structure open in another window while you are editing so you can see the field names
• Use line dividers to separate fields into groups:  Pull Options, Display, RSS Feed Options

11:15 – Plugin Training Part 1 — don’t know how well I will do here, lots of information and I want to play with it  We’ll see how I do

• Jason Tesser is presenting …
• “How to extend and add functionality to the dotCMS”
• Lots of flexibility and power, be careful, you can brick your system
• Who can use plugins?
  • Sys Admins – Configuration
  • Java Developers – View tools and so forth
  • Web Developers – Macros/widgets and so forth
• Deploying  a plugin means stoppin/starting the system
• What can we do in plugins
  • Macros — New or overriding existing ones the right way
    • This is the only way to really override an existing dotCMS macro
  • Config
  • tinyMCE Config and adding plugins for tinyMCE
    • It is just some HTML but it is in a JSP so you can do things like show different things for different users
  • Velocity Tools
  • Custom Java
    • Override DotCMS java and libraries
    • New tooling, servlets, web services
  • JSP
  • Backend Tooling
    • Velocity / Struts/ or JSP Portlets
• What’s really important about plugins for Jason — Understanding How it works and what it can do
• Plugin Idea:  Create a UI to control tinyMCE based on user roles.
• You don’t have to understand the java stack to create a viewtool.  All the API’s are there to do it for you.  It is very easy, not a scary thing
• Plugin Idea:  Create a plugin to pull in your SIS or an external Database system as back-end tooling – portlet
• Query Test Tool in 1.9 beta is a JSP portlet.
• Eclipse is not that scary — just take some time to learn it
• Example of an external system brought in via iframe and velocity portlet from @fienen:  http://ow.ly/1ySwb
• How do they work?
  • Build/Compile
    • One of the primary weaknesses to deploying plugins you have to get to the filesystem
    • You need root access to do this
    • This is not changing in 1.9 but in 2.0 it might with OSGi
  • Deploy
    • By default plugins are deployed in reverse alpha
    • Plugins can overload themselves if you are not careful
    • You can specify the order by modifying the plugin configurations
    • Plugin names are the folders they are stored in and must be unique.  Of course you can’t create 2 folders with the same name, so that won’t be too hard to stick to
    • Don’t just delete a plugin without undeploying it first!!!
    • Your files are put in a JAR file and dropped in a place with your Libraries
    • in 1.7 tomcat was modified for the deploy to work — DotCMS 1.9 is totally different in this respect.  DotCMS can now deploy to potentially any other container as a war file.
  • Configuration
  • Properties
• dotCMS Architecture
  • Current Status
    • DotCMS is not a new puppy.  This is why the old stuff is still around like old struts and hibernate.  The effort to change this would be huge and not beneficial to us as the customers.  What would be the value add?
    • DotCMS 1.7 has this problem — everything is cached in memory so it does not have to hit the DB.  Where this falls apart is when there is not enough room in memory it has to hit the db and this is expensive.
    • In 1.9 there is a new velocity library because we need the cache on disk to combat this problem
    • Jason is laughing about his use of little guys.  He calls every little component in dotcms a guy
    • These changes made to velocity engine are looking at going back to the velocity project
  • Future Development – New Architecture
    • Possibly upgrade Hibernate
    • Not going to upgrade struts
    • The code has been around a long time.  Some of it is better than others.   The older stuff doesn’t practice good MVC.  But changing this is really hard and again, what is the value for the customer?
  • Legacy -vs- New Code
    • Morale of the story is use the APIs
• Alright the intro is over — stay tuned for the next session for part 2 for some depth into this info.

12:45 – Time for Lunch.  I am starvin!

2:15 – Plugin Training Part 2

• Jason is reviewing part 1 now
• Plugin Development
  • Viewtools
    • This is where you add new functionality for your pages.
    • When it can’t be done in just velocity.
    • When do you use viewtool or struts or Macro/Velocity?
      • It can be done many ways
      • Velocity is for spitting out content on a page
      • Computation and work is done in a viewtool
      • When it is inconvenient to do a viewtool then you need struts
      • When you do not really need to send to a page, just do some action.  Velocity always needs to go to a page
      • Jason can only think of using struts or servlets for handling a form
  • Macros
  • Struts / Servlet
    • Struts gives you the message guy for handling errors and validation and so forth
  • Portlets
• Jason is showing us the hello world view tool
• “Let your plugin guy handle that”
• Viewtool Scope:
  • Request — every request he dies
  • Session — every web session he dies
  • Application — only one ever
• Now he is showing the guy in action
• “Always a good idea to throw velocity code in a simple widget”
• plugins.xml is where you set the order your plugins are deployed is set.
• If your plugin configuration is malformed it is going to deploy malformed
• ant -p — displays all the ant targets
• there is a .bat .sh script to help you deploy your plugins in the bin directory
• You can run ant directly from eclipse by right-clicking the main build.xml > run as
• Jason is going over the different Config files you can alter in plugins
  • Hiberbate mapping files — skipping these with a brief explanation of what they are and why
  • dotmarketing-config-ext.properties — modifies the main dotcms configuration
  • dwr-ext.xml — AJAX Library configuration – exposes Java classes to Javascript (Jason doesn’t like this — he uses jQuery load some html method)
  • Language-ext.properties — Language Variables for your portlet
  • liferay-portlet-ext.xml
  • portal-ext.xml
  • portlet-ext.xml   — all 3 for deploying portlets
  • macros-ext.vm — there is where you create macros
  • plugin-controller.properties — this is where you wire hooks like preContentletHooks.  There are a lot of uses for this
  • plugin.properties — allows you to have properties for your plugins
  • struts-cms-ext.xml — for struts on the front-end
  • struts-ext.xml — for struts on the back-end
  • system-ext.properties — configuration for the system, velocity stuff
  • portal-ext.properties — ldap config and so forth
  • tiles-defs-ext.xml — struts and portlet stuff
  • toolbox-ext.xml — for wiring your viewtools
  • urlrewrite-ext.xml — rules for the url rewrite filter
  • web-ext.xml — servlets and filters config
• It’s always easier to edit than reuse — Jason had said this 3 times now
• Nice plug from Jason for the IRC channel in #dotcms on freenode
• Jason is going to show us the scripting plugin
  • The scripting plugin allows you to access all the java classess on the classpath via the language of your choice — no plugin no viewtool quick and easy
  • Showed us how to get your user from a viewtool — look at the plugin it is not as easy as you think, but it isn’t too much to get it.
  • Showing us how he modified the CMS Filter
    • Created his own filter extending the dotcms CMS Filter
    • Skip processing and move on if you are a php file
    • Otherwise call the super.doFilter()
• All done folks — see you next year

Last night opened with a cocktail party for some social networking.  It was great to meet back up with some old friends and meet some new ones as well.  It was kinda sad that a lot of the folks that didn’t get to make it.  We miss you fusion27, bradrice, and all the other folks from the IRC channel that couldn’t make it.  After the party a bunch of us went to Sushi Samba — AMAZING, I really recommend it.

8:30 AM:  Breakfast in the Hotel was nice.  The weather here in Miami is amazing.

9:30 AM:  First Session:  DotCMS Roadmap.

• Tim is up to kick off the session
• Plug for the mailing list and the IRC channel:  #dotcms on freenode — Feel free to join in
• Tim is passing it off to Will
• Jason Tesser and David Tores are co-presenting
• 1.9 …
  • 1.9 Has thousands of improvements over 1.7
  • Expected to ship 1.9 in June/End
  • 1.9 Beta was released yesterday
  • One more big piece for 1.9 … scripting plugin is going to be built into the core of dotCMS:  PHP, Groovy, Python, Server Side Javascript
• What is coming for 2.0?
  • API/DB Updates
  • UI/UX Sugar
  • Enterprise Support
  • Multi-tenant features
  • Marketing Tooling upgrades
  • Revisit Workflow
  • Functionality via modules
• Will passed it to Jason to talk about API/DB Stuff
  • Normalization of Identifier and Tree Tables !!!  his is huge for anyone going straight to the DB for development/searches
  • End of Limits to structures
  • SQL to Lucene Translator — Ability to write SQL against the Lucene Index!!!  HUGE.
  • API Refactoring in Folders, HTML Pages, File Assets — Allow you to write plugins that won’t break from version to version, of course this will break plugins initially
  • Upgrade to Hibranate 3.X and OSGi
  • OSGi –
    • Injecting things into the menus/UI hooks
    • Hot deploy plugins
• Jason Passed to David to talk about UI/UX Changes
  • Front End inline content editing — in place editing!!
  • Simple Content Search —  Think gmail interface, simple, intuitive for users.  Single field searcing, autocomplete, with advanced options of course
  • Better Image tooling — cropping and rotating — for users
  • Continue to make it suck less — yes that is actually a bullet point.  Many small improvements to the UX
  • Better Error Handling and reporting for velocity developers — THANK YOU!
• Back to Jason for Enterprise Deployment
  • Was push publishing – Now called sync engine
  • This is a step towards this
  • Having multiple live servers and keeping them in sync
  • The code is there for this in 1.9 — but the tooling is not done
  • This is not so much pushing dotcms content to an IIS server as dotcms to dotcms (this is what CMIS for)
  • Staging > Live system
• David on Multi-Tenant
  • Becoming your own onDemand CMS Provider and maintaining control — divide websites between clients
  • Delegated User Management
  • Putting Users on Hosts
  • Cloud-Based Mega Deployments — Need a new instance or more power for a new client, just add it via cloud computing ALA Amazon EC2
• Jason for Marketing tools
  • Currently it sucks
  • Retooling the eNewsletter process to utilize 3rd party SMTP services
  • Separate users from customers
  • Users as content types – extendable and flexible — powering the developer
  • Tools for browser compatibility and 404 checking
  • HostWatch dashboard – aggregating analytics internal or external across your sites
• David for Workflow
  • currently workflow is not powerful enough
  • Not doing things like JIRA, more tied to the website
  • 1 click default actions for all the tasks that are currently tedious
  • Batch Actions — Publishing/Reviewing multiple objects at the same time
  • Multiple Approval Steps — Not rule based, but allowing for multiple steps instead of just one approval
  • Better emails for workflow that allow you to take action directly in the email instead of having to log in
  • Preview Token – viewing staged content without logging in
  • Don’t bog it down with complexity — keep it simple but extend the functionality
• Will is up for the Enterprise Modules
  • Some of the things they are working on now:
    • KonaKart eCommerce Module
    • Real Wiki Module
    • User Forum Module
    • Intranet Module
    • Document Management Module
    • Data Import/Export Module
    • Server Management and Profiling tools
  • Things that can be deployed as plugins or modules to the system — not core features but extending the system to meet your needs.
  • They are adding the hooks now to make these kinds of things possible
• That is it for the roadmap folks
• 2.0 will be about 6 months after 1.9 — speed up release cycle (I’ve heard this before)

10:30:  You got and OutofMemoryException, no what?

• The session hasn’t quite started yet.  Waiting for people to return from break
• Andres Olarte and Nick Rodriguez up for the session
• Identifying the problem
  • Memory Related — could be caused by a series of events or a single event
  • Performance — Hard to identify the problem
  • Stability — Mostly caused by bugs or a combination of many different elemetns
  • Front-End -vs- Back-End
    • Front end relies on cache (in memory and on disk (1.9)) and lucene index
    • Going to the Cache can be expensive if there is not enough room in memory that is why in 1.9 is moving to allow cache overflow on disk, going to a cache on disk is much more performant than going to the DB, figuring out the permissions and all that.
    • A page is made of multiple layers — Template, Container, Contentlet, Fields — all cached separately for performance
    • Back-end always goes to database
  • Tools available
    • JMX — Standard protocol provided by Java which allows you to peek into the JVM
    • Logs — First line of troubleshooting — but they are noisy and hard to process.  (it would be nice if these were available in the UI — HINT HINT)
    • Talking to the user to identify what is actually wrong
    • Logs are good when it is one page causing the problem
    • JMX is going to be better if the server is going down after a certain amount of time and can’t be blamed on one specific page
• Creating a baseline
  • Simulate Traffic
    • Use access logs as test base
    • Organic traffic is really hard to simulate synthetically
  • Andres is showing a demo now — how to create the baseline
    • Compile a list of url from the access log of all the urls for a day or some amount of time
    • He is using siege to hit this list of urls
      • 40 users for a min
      • Ignore the first run — let the cache do it’s job
      • he got 45 transactions per seconds
      • You shouldn’t have any urls that are particularly heavy to load or simple
    • He also uses jMeter and Bad Boy
    • He is using Java Monitoring and Management Console now (jConsole)
      • Memory Usage, CPU Usage, and Threads are important here
        • When Garbage Collection runs you want it to reclaim a bunch of memory.
      • Classes are not as important
      • Gives you an online thread dump on the fly — this is very valuable
      • VM Summary gives some useful information  like uptime, startup and so forth
      • MBeans are information we can examine and change on the fly
        • Here you can actually examine what is in cache
        • velocityCache is where everything lives
        • He increased the Velocity Cache from 100 to 5000 and is rerunning the siege test … ok that wasn’t much better
        • Don’t test while the spellchecker is initializing
        • Ran again and now we are 51 trans/sec
        • Make one change at a time when testing
        • JMX will change your baseline
        • Balance between memory management and performance increase
• Understanding the system
  • Java memory management
    • Garbage Collection — it needs to run, but it shouldn’t run very often
  • Memory Utilization
    • More memory gives you better performance, this is the best way to increase performance
  • Database Usage — it is expensive no matter how beefy your DB is
  • Common Bottlenecks
    • Saving Content — if you have huge imports running in the background checking in a content can be expensive
• Memory Issues
  • JVM Memory configuration
    • If you have threads locked in completely random places it is most likely a garbage collection issue
  • Cache Config
    • Region sizes
    • Time to live — Change and make sure you watch how that affects your baseline — it may or may not help
  • Per request memory usage
  • Per session memory usage — when is the memory stored per request, per session
  • Only pull data that you need, don’t filter and sort in velocity
• Performance Issues — Nick is up now
  • per page performance
  • System-Wide performance
    • Garbage Collection — looking at this can show you if you are having an issue
    • http -vs- https — https is more expensive
  • Resource utilization
    • Database Connections
    • Client Connections
    • Enough connections to handle the requests — this is managed in the ROOT.xml  – 1 DB connection per Client connection plus a round number of buffer
• Best Practices — Andres is back up
  • Assign as much memory as is available
  • But use as little memory as possible
  • Limit the amount of data used on each page — again only pull what you need don’t filter in velocity
  • When Benchmarking, change one thing at a time to see how that affects your baseline
• Questions
  • Garbage collection management is really really hard
    • You need enough memory for GC to run effectively
    • Memory will grow at a certain point GC will run
    • When GC runs the system locks
    • If GC is happening a lot you are locked a  lot
    • This is why it is bad to increase your regions too much.
    • Identifying it –
      • Taking a thread dump: kill -3 PID
      • Use thread dump analyzer to examine it:  https://tda.dev.java.net/ — very nice
      • Look for locked up threads — locked without an explicit lock, that is probably garbage collection
  • There may be some issues with redhat linux 64 and Java 6 in re: Lucene
  • To view Cache info in jConsole:  org.dotcms > Cache Info
• End of the session folks time for lunch

12:00 Lunch

1:45  Starting the next session on Mobile Development with DotCMS  Presentation is from http://aquent.com/

• Mobile site for a device that runs a browser with HTML, Javascript, CSS
• The Challenges
  • Frequent Updates
  • Multilingual Content
  • UI Between Devices
• Staff Profiles updated Daily
• 8000+ fields
• 22 Languages — Word lengths & Different Markets
• UI differences between devices
  • Use a single webkit don’t develop different UIs for each device
• Authentication — using Google OpenID — very cool tie in for DotCMS — maps the user roles and everything
• Going further they are looking at ajax for the auth
• He wants us to try it on our phones:  http://dir.aquent.com/
• Data size — what can you cut down to make it smaller for the mobile device.
• Methods:
  • UI Design
    • HTML/CSS/JavaScript
    • Unified Design — look at wikipedia’s mobile css, it works just about everything
  • dotCMS coding method
    • DWR
      • Loads fast
      • harder to develop
      • JS Required
    • PullContent
      • Fast to develop and easy
      • Slow to load and overloads server
      • no JS required
• Now a demo of his website
  • homepage is pulling content from the dictionary
  • it’s literally only like 5 lines of code
  • Uses user agent to detect the browser
  • Don’t enable-mobile in every page just the main content they will be accessing
  • disabled form validation for phones

2:30:  The session is over now, just people asking questions — I am stoked to hear Michael Fienen’s Presentation (Who is sitting next to me) on DotCMS Best Practices next

3:00 Michael’s Session is starting soon.  I look over and he is finishing up slides as we speak.

• Maria is co-presenting with Michael
• Container Must haves
  • A Container for Includes — global variables, macro testing, Cache busting for CSS/JS
    • Set a quote variable for queries #set($quote = ‘”‘)
  • Meta Container – Page title, Meta tags, CSS, JS
  • Stats Container – For Google Analytics and others
    • Use the $host variable to determine the hostname
• Templates -vs- Container
  • Templates should only be used for layouts.  Try to use as few as possible
  • Contains are things you reuse or are editable
  • Doctype should be in the template
  • <head> should be in template, and CSS/JS that is specific to the templates
• VTL files
  • Limit use of vtl files for simple widgets
  • Save them to a central directory
  • To override a macro’s vtl files
  • Don’t abuse them
• Widgets
  • Simple Widgets — dynamic code that doesn’t need parameters – generic, dynamic tools
  • Structured Widgets — Take parameters — A front-end for macros
• URL Maps — coming in 1.9
  • ties a url for the details page to a field in your structure
  • Use a custom field for the “slug” to build the slug for you based off of your title
• Custom Forward pages
  • /cmsHomePage virtual link for your homepage
  • You can also do this with /cms###Page for 404, ect.
  • Build an automatic 404 reporter off of the vtl servlet url
• Valid HTML and 508 Compliance
  • Validate your code before you spit them out
  • TinyMCE will not do this for you, it tries, but it doesn’t
  • MS Word Hates the Interent
• Get @fienen on twitter or http://www.google.com/profiles/fienen
• dotCMS Cheat Sheet – http://tinyurl.com/dotcmscheatsheet
• DotCMS book coming out with 1.9 — hopefully
• You can customize the TinyMCE editor

Ok that’s all for today folks — watch for another post tomorrow.

This past week I needed to get an iCal feed created for my DotCMS Calendar.  What I came up with might not be the most elegant solution, but it does the trick for Outlook and Google Calendars at least.  So I thought I’d post up my process …

First I started by creating an HTML page in DotCMS, and choosing the Blank Template.  The next thing I did was create a new contentlet.  The important thing to remember about this step is to name your contentlet something that is going to be ewasy to remember.  The reason for this is that doing this will break the DotCMS Page Editor.  You’ll see why a little latter.

Now for the code:

$response.setContentType('text/calendar')
$response.setHeader("Content-disposition","attachment;filename=calendar.ics")
#set($today = $UtilMethods.now())
#set($fromDate = $date.format("MM/dd/yyyy", $today))
#set($endDate = $UtilMethods.addDays($today, 30))
#set($toDate = $date.format("MM/dd/yyyy", $endDate))
#pullContent("+structureInode:135155  +date1:[01/01/1900 00:00:00
TO $toDate 23:59:59] +date2:[$fromDate 00:00:00 TO 01/01/3000 00:00:00]
+languageId:1 +deleted:false +live:true" '0' 'date1')
BEGIN:VCALENDAR
PRODID:-//Microsoft Corporation//Outlook 9.0 MIMEDIR//EN
VERSION:2.0
METHOD:PUBLISH
CALSCALE:GREGORIAN
X-WR-TIMEZONE:America/New_York
X-WR-CALNAME:EUP Events
BEGIN:VTIMEZONE
TZID:US-Eastern
LAST-MODIFIED:19870101T000000Z
BEGIN:STANDARD
DTSTART:19971026T020000
RDATE:19971026T020000
TZOFFSETFROM:-0400
TZOFFSETTO:-0500
TZNAME:EST
END:STANDARD
BEGIN:DAYLIGHT
DTSTART:19971026T020000
RDATE:19970406T020000
TZOFFSETFROM:-0500
TZOFFSETTO:-0400
TZNAME:EDT
END:DAYLIGHT
END:VTIMEZONE
#foreach($content in $list)
BEGIN:VEVENT
DTSTAMP:$date.format("yyyyMMdd'T'HHmmss", $content.startDate)
DTSTART:$date.format("yyyyMMdd'T'HHmmss", $content.startDate)
DTEND:$date.format("yyyyMMdd'T'HHmmss", $content.endDate)
SUMMARY:$!content.title
UID:$!content.identifier
PRIORITY:3
CATEGORIES:MEETING
LOCATION:Edinboro
END:VEVENT
#end
END:VCALENDAR

Let me pick this apart section by section. First off we have what I like to call, “The Magic” of this whole thing:

$response.setContentType('text/calendar')
$response.setHeader("Content-disposition","attachment;filename=calendar.ics")

What this little bit of code does is set content type for the page, and tells the browser that this should be downloaded, not displayed in the screen. It also tells the browser exactly what the filename should be that they are downloading. This allows us to set the extension of .ics.

#set($today = $UtilMethods.now())
#set($fromDate = $date.format("MM/dd/yyyy", $today))
#set($endDate = $UtilMethods.addDays($today, 30))
#set($toDate = $date.format("MM/dd/yyyy", $endDate))
#pullContent("+structureInode:135155  +date1:[01/01/1900 00:00:00
TO $toDate 23:59:59] +date2:[$fromDate 00:00:00 TO 01/01/3000 00:00:00]
+languageId:1 +deleted:false +live:true" '0' 'date1')

Note:  I had to break up the #pullContent into 3 lines so it would fit on the page, this should be one line.

This bit of code is probably fairly familiar to most of you reading this. Basically it is pulling the events from the last 30 days. You will of course need to make sure you change the structureInode to match what your Event Structure’s Inode is.

BEGIN:VCALENDAR
PRODID:-//Microsoft Corporation//Outlook 9.0 MIMEDIR//EN
VERSION:2.0
METHOD:PUBLISH
CALSCALE:GREGORIAN
X-WR-TIMEZONE:America/New_York
X-WR-CALNAME:EUP Events
BEGIN:VTIMEZONE
TZID:US-Eastern
LAST-MODIFIED:19870101T000000Z
BEGIN:STANDARD
DTSTART:19971026T020000
RDATE:19971026T020000
TZOFFSETFROM:-0400
TZOFFSETTO:-0500
TZNAME:EST
END:STANDARD
BEGIN:DAYLIGHT
DTSTART:19971026T020000
RDATE:19970406T020000
TZOFFSETFROM:-0500
TZOFFSETTO:-0400
TZNAME:EDT
END:DAYLIGHT
END:VTIMEZONE

This is the begining of the iCal Code. It defines the Time Zone, the name, the version, and various other tidbits. I found it was necessary to put in the vTimeZone element for the calendar to show up in Google in the right times. I also found a nifty reference of the iCal Format Here.

#foreach($content in $list)
BEGIN:VEVENT
DTSTAMP:$date.format("yyyyMMdd'T'HHmmss", $content.startDate)
DTSTART:$date.format("yyyyMMdd'T'HHmmss", $content.startDate)
DTEND:$date.format("yyyyMMdd'T'HHmmss", $content.endDate)
SUMMARY:$!content.title
UID:$!content.identifier
PRIORITY:3
CATEGORIES:MEETING
LOCATION:Edinboro
END:VEVENT
#end
END:VCALENDAR

The rest of the code is fairly straight foward I think. Loop through each contentlet and create a vEvent item then bookend with your ending vCalendar. The hard part is the Time Format. I found putting in the Timezone here did not work in Google, perhaps you will have better luck.

Now, I know this isn’t perfect. I haven’t put in descriptions and nice locations and all that. This was a quick and dirty write-up to get what I needed done. I hope it benefits you, if you have any questions or suggestions I’d love to hear from you in the comments.

Where to go from here? I would love to see this macroized and/or wigitized and put into a plugin. I hope some day I have time to beef it up and learn more about what I can and can’t do with iCal. I would also like to put in the ability to give iCal Feeds for specific categories and tags. Ultimately, I would like to see the iCal download servelet that already exists in DotCMS fleshed out to this natively within the CMS.

Please if you have any suggestions on how to make this better or any improvements you’ve made on this, I’d love to hear about it in the comments.

Step 1:  Generating a Keystore

The first steps is to generate the keystore.  Tomcat, the java application server that DotCMS runs on, uses a format called Java KeyStore (JKS) for it’s keystores.  The Java SDK provides all the tools necessary to get the task done.  So, hop on over to where you have your SDK installed and follow along

C:\Program Files\Java\jdk1.6.0_03\bin>keytool -genkey -alias tomcat -keyalg RSA -keystore C:\DotCMS_keystore.key

You will need to enter some information about your organization and location.  You will have have to choose a password for your keystore.  Don’t forget the password or you’ll have to start over.  You should now have a valid keystore with the alias of tomcat.

Step 2 – Generate a Certificate Request

With the keystore in place you could skip all the way to the end now and have a fully functioning self-signed certificate.  This is nice, but more likely you are looking to have a certificate authority such as DigiCert or Verisign sign your certificate.  To do this you are going to need to generate a CSR or Certificate Signing Request.  Thankfully the keytool takes care of that for us as well.

C:\Program Files\Java\jdk1.6.0_03\bin>keytool -certreq -alias tomcat -keyalg RSA -keystore C:\DotCMS_keystore.key -file c:\DotCMS_certreq.csr

You are going to be required to enter your keystore password, but this should generate the certificate request for you without too much trouble.  Now you can take your DotCMS_certreq.csr to your signing authority and submit a request for a certificate.  I am not going to cover that process because  I don’t do that part, my sys admin does.  Well, it is also different with each signing authority.   Once you have your certificate you are ready to start the next step.

Step 3 – Importing your certificate

C:\Program Files\Java\jdk1.6.0_03\bin>keytool -import -trustcacerts -alias tomcat -file c:\star_edinboro_edu.p7b -keystore c:\DotCMS_keystore.key

Again, the keytool handles the dirty work for you and you’ll need that password again.

Step 4 – Checking the details

You could probably skip this step if you know you have the right password.  Honestly the output of this command really didn’t tell me much other than I could see that my certificated had imported.

C:\Program Files\Java\jdk1.6.0_03\bin>keytool -list -v -keystore c:\DotCMS_keystore.key

Step 5 – Configure DotCMS to listen on Port 443

The next step is going to require you to head to your DotCMS’s server.xml  Add the following lines:

<Connector port="443" address="192.168.8.221"
protocol="HTTP/1.1"
maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
SSLEnabled="true" scheme="https" secure="true"
clientAuth="false" sslProtocol="TLS"
keystoreFile="C:\DotCMS_keystore.key"
keypass="..."  />

You will have to change the address and keypass to match your system.

Step 6 – Restart and test

That’s really all there is to it.  Restart your DotCMS service and you can use openSSL to test the connection just like telnet.

C:\Program Files\Java\jdk1.6.0_03\bin>openssl s_client -connect 192.168.8.221:443 -state

After it establishes a connection you should see your certificate information.  You will of course want to test the whole setup in a browser.

In order for DotCMS to use SSL you also need to set a page to use SSL in the properties.  Create a test page, but before you save and publish head to the advanced properties and check the force https option.  Now when you try to visit that page it should redirect you https if you are not already using it.

Hopefully this small little guide helps out anyone trying to figure out how to setup SSL in DotCMS.

Tuesday, Feb 3

My journey to Miami started a day before the conference.  I couldn’t get a flight in the day of the conference.  It was fairly uneventful (that’s good!).  The Hotel this year was the Mayfair.  A little more ritzy than the Sonata, but still very nice.  I ended up eating at the Johnny Rockets.

Wednesday, Feb 4

The conference didn’t officially start until the registration/welcome party at 6PM.  Since I was there quite early I decided to jump over to DotMarketing Headquarters about 1PM.  DotMarketing was nice enough to throw us Jason Tesser for some informal pre-conference training.

We talked a lot about the bits and pieces of DotCMS.  Here are some take-aways from that conversation:

• Lucene queries will no longer require the live, deleted, and language parameters.  The DotCMS code tries to be smart enough to put those in based on where you are in the system.  This should simplify the lucene quries in our code considerably.
• DotMarketing plans on hitting the Content Browser Search functionality with a hammer very soon.  They want to add a more intuitive search.  The idea is to make the search much more like a Google search.  A very simple one field search with advanced option and more intuitive operators.
• They removed multicast traffic in clustering.  This is coming in the next version, but it is a major improvement on the way clustering works.  At Edinboro I decided to nix the cluster because of the multicast issues on campus.

After the informal training we went back to the Hotel for the opening party.  I got to meet back up with Fienen and meet some of the new folks from the DotCMS Community.  A big welcome to IPFW who just made the decision to go with DotCMS and had a considerable force at the conference.  After the party we (Jason, Fienen, and some others) headed to the Knife for dinner.  The Knife was a very nice place to eat.  It is an Argentinian Steak House Buffet kinda thing.  Very Nice!

After dinner I had mega troubles with my laptop’s wireless.  So that’s why this post is coming a little late.

Thursday, Feb 5

Thursday started with breakfast at the Bookstore in the Grove.  The first session of the day was on structures and relationships.  I already knew much of the content here, but for the new guys this was a lot of bricks and mortar kind of training on the Back-End of DotCMS.  I did manage to grab a couple morsels of goodness from the session though:

• Relationships have an order field but in order to get the #PullRelatedContent macro to sort on that field you have to first save the order in the back-end.  Then, if you leave the sort parameter blank your results will be sorted by that field.  This is something I had been wondering how to do for some time now.
• You can also pass a lucene query to the macro.  Allowing you to drill down the results to just what you need.  I couldn’t think of an immediate use for this, but I’ll tuck it away for a rainy day.

The rest of the day, I spent with Jason Tesser in a one-on-one session.  This is the true value of the DotCMS conference.  I am really happy to see a company that will give you one-on-one attention.  Jason and I talked a lot about the nuts and bolts of the Content API and DotConnect Java Classes.  I learned how to use the DotConnect Class to retrieve SQL results from my server and then use the Content API to update and insert new content into DotCMS structures.  Very, very valuable stuff.

After the show a few of had a specialized training on administration of DotCMS.  We learned that you can use JMX to debug some of the more interesting problems may run into with cache and other things in the system.  It looked like really cool stuff, but it was a bit over my head.  Andres did a great job of showing us what can can’t be done though.

I ended up going with a rather large group to a sushi place for dinner.  I am not overly obsessed with sushi, but I went along and the place we went to was very nice.  I had a fried shrimp/lettuce/rice roll that was actually very good.

Friday, Feb 6

Breakfast was at the bookstore again.  We started the day off with Plugins Training.  The training was very well laid out and was my main target for the conference.  Jason covered a ton of information about what you can do with plugins and how they work.  I wish there was more actual code, but when you are talking to a large audience that kind of thing would’ve been hard to pull off. I can’t say how stoked I am about the addition of plugins to the DotCMS product.

One of the cool things you can do with plugins is move all your configuration and custom macros out of DotCMS.  This way if you ever need to restore a server or do an upgrade, you can just stick your plugin back in and you are essentially up and running.  I plan on doing this as my first plugin and hope to have a good post about how it’s all done.  That is, or corse, if Fienen doesn’t beat me to it

The last half of the day was on Ajax.  While I was not overly interested in the ajax stuff, it was interesting to see some of the cool stuff that DotCMS can do there.

After the Ajax session we moved into the Focus Group / Roadmap / Deiscuss / Wrapup portion of the conference.  I can’t tell you how impressed I am with the way DotCMS is developing.  Here is what is in store for us in the coming year:

• Enterprise Offeringe -vs- Open Source Offerings:  The idea is is to not turn DotCMS into crippleware.  There are quite a few CMSs that go the crippleware route.  In other words, you can have the software for free, but to really get the most out of it you have to pay.  DotCMS is going pretty much the opposite route.  The open source product will always be fully featured.  (Actually, it will most likely be more featured than the Enterprise. )  The Enterprise version will be the hardened product with better supoprt.
• Plugins, Plugins, Plugins:  Plugins give us a major shift in the way customization of DotCMS is handled.  From the simplest stuff like your configuration or a small macro, to the big stuff like new portlets.   Plugins also push forward community growth.  We hope to see the infamous DotCMSForge this year.  To add to this DotMarketing is also going to be putting on a plugin competition to get the community start on making plugins.
• 1.7:  What was going to be 1.6.5c is now going to be 1.7.  With this version, slated to come out in the next few weeks, we will see the addition of plugins.  Also, as a first plugin DotMarketing has created Front Ent Content Submition.
• 1.8: With 1.8 we will see fater releases (to the tune of 1 every 3-4 months).  1.8 will also add the concept of Binary Content.  This will allow us to dirrectly attach files to content along with exporters.  This esentially turns DotCMS into a digital asset / document management system.  Also due for 1.8 is drafting.  The idea is that it will work much like wordpress posts that auto-save or gmail messages.  There are also changed coming for content/page owners, which is something that has not worked as intended in DotCMS.  Lastly, it will add wiki-like link structures to DotCMS.
• Looking beyond 1.8 there are some big plans for this year.  A simplified UI for permissions, improvements to the Multi-Site Hosting UI, Push Publishing, a better forms builder with chaining, and access to content in the CMS view web services over CMIS.

Wrap Up

So, this has been a really long congolomo-blog post.  Sorry for that.  As you can see the conference was a great source of information!  I thouroughly enjoyed myself and I think everyone that came got a ton of value out of it.  Not to mention the networking possibilities.    There are some really cool things in store for us this year.  To say that I am giddy with anticipation would be an understatement.

Here are some additional links to information about the conference (more as I find them):

• Fienen’s Live Blogging of the Conference:  Post 1 | Post 2
• Fienen’s Flickr Feed

Also, Don’t forget to vote for me in the .eduGuru Blogger Contest: 
http://feeds.feedburner.com/~r/DotEduGuru/~3/463906741/id1326-blogger-search-vote.html

Thanks!!

http://waaagh.wordpress.com/2008/11/18/realm-war-changed-or-standing-still/

Check it out!!

So, I decided to jump on over and write a guest post to enter the contest.  Head on over to .eduGuru and check out my post and don’t forget to vote for me:

http://doteduguru.com/id1182-xenu-broken-link.html

Thanks!

http://weekendgamer.wordpress.com/2008/11/04/weekly-warhammer-wrapup-episode-3/