Optaros Blogs | Open Source

WPBook 1.5 Released – Let the Streaming begin!

jeckman — Mon, 08 Mar 2010 00:03:34 +0000

WPBook

So for a while I’ve been working on and beta testing the next version of WPBook. Tonight I’ve just tagged it for release, so it will be available for download shortly. (I’ve already been running it here for a while and testing it on a few other test blogs).

The main improvement in WPBook 1.5 is that it now knows how to use stream.publish, meaning that it will automatically post to your wall in Facebook when you publish a post in WordPress. Your friends should see that notification as well in their streams. (We’re not, however, sending application updates or tracking all users’ user id’s – instead you enter your own userid into the settings and it uses that to post to your wall). Included are attachments (first image attached to the post is used) and excerpts (if you hand craft excerpts they will be used in the wall post).

The other main improvement is that WPBook now requires PHP5, and as such can wrap Facebook calls in Try/Catch blocks. For the non-programmer, this means those awful, dramatic “fatal uncaught exception” error screens are gone. WPBook isn’t doing anything terribly meaningful with those errors yet – still working on that- but at least it traps them.

In this release:

WPBook now requires PHP 5
Enables user to post to stream, including to pages. (Must be pages for which you are the admin, to which you have added the app, and which have granted stream.publish permission – link provided in the admin to grant permissions.
Catches exceptions thrown by the Facebook client. (Doesn’t yet surface those in good error messages, but at least they are caught)
Fixed, I hope, issue with comments inside Facebook for some users
Clean up of some admin styles (resized gravatar images as well as some basic hierarchy on options)
Added Page Options as their own section
Allow user to select pages to be excluded
Added option to allow a menu of parent pages at top of the app below the title
Fixed “Facebok” typo in line line 182 of theme/index.php
Option to turn on and off page list under content (independent of menu)
Option to turn on/off recent post under content
Allow user to set the amount of recent post to show under content (default 10)
Cleaned up custom header/footer now only one function instead of two (no reason to have two functions)
Added %tag_links% and %category_links% to custom header footer as well as made archive pages work.
Set smart default for when Blog Title isn’t set

Next steps?

Better error handling code – do something with the messages Facebook returns when an exception is thrown
User selectable theme directory – for users who’ve taken the time to customize their theme
Threaded comments – likely means requiring WP 2.7, though for error handling (and just simplicity) I’m thinking of jumping right to WordPress 2.8
Cross-Posting to a commenter’s wall when they comment inside Facebook. (Because it is in response to a user action, I understand they don’t even have to grant stream.publish permission).

What else would you like to see?

cmislib: A CMIS client library for Python

jpotts — Fri, 18 Dec 2009 17:41:49 +0000

I’ve started a new project on Google Code called cmislib. It is an interoperable client library for CMIS in Python that uses the Restful AtomPub Binding of a CMIS provider to perform CRUD and query functions on the repository.

I created it for a couple of reasons. First, it’s been bugging me that, unlike our Drupal Alfresco integration, our Django Alfresco integration does not use CMIS. After talking it over with one of our clients we decided it would make more sense to create a more general purpose CMIS API for Python that Django (and any other Python app) could leverage, rather than build CMIS support directly into the Django Alfresco integration.

Second, around the time I was putting together the Getting Started with CMIS tutorial, it struck me that there needed to be an API that didn’t have a lot of dependencies and was very easy to use. Otherwise, it’s too easy to get lost in the weeds and miss the whole point of CMIS: Easily working with rich content repositories, regardless of the underlying implementation.

Even if you’ve never worked with Python before, it is super easy to get started with cmislib. The install is less than 3 steps and the API should feel very natural to anyone that’s worked with a content repository before. Check it out.

Install

If you don’t have Python installed already, do so. I’ve only tested on Python 2.6 so unless you’re looking to help test, stick with that.
If you don’t have setuptools installed already, do so. It’s a nice tool to use for installing Python packages.
Once setuptools is installed, type easy_install cmislib

That’s all there is to it. Now you’re ready to connect to your favorite CMIS-compliant repository.

Examples

There’s nothing in cmislib that is specific to any particular vendor. Once you give it your CMIS provider’s service URL and some credentials, it figures out where to go from there. But I haven’t tested with anything other than Alfresco yet, and this thing is still hot out of the oven. If you want to help test it against other CMIS 1.0cd04 repositories I’d love the help.

Anyway, let’s look at some examples using Alfresco’s public CMIS repository.

From the command-line, start the Python shell by typing python then hit enter.
Import the CmisClient and Repository classes:
Point the CmisClient at the repository’s service URL
Get the default repository for the service
Get the repository’s properties. This for-loop spits out everything cmislib knows about the repo.

Once you’ve got the Repository object you can start working with folders.

Create a new folder in the root. You should name yours something unique.
Then, you can create some content:
And, if you want, you can dump the properties of the newly-created document (this is a partial list):
You can also use cmislib to run CMIS queries. Let’s find the doc we just created with a full-text search. (Note that I’m currently seeing a problem with Alfresco in which the CMIS service returns one less result than what’s really there):
Alternatively, you can also get objects by their object ID or their path, like this:

Set Python loose on your CMIS repository

These are just a few examples meant to give you a feel for the API. There are several other things you can do with cmislib. The package comes with documentation so look there for more info. If you find any problems and you want to pitch in, you can check out the source from Google Code and create issues there as well.

Give this a try and let me know what you think.

[UPDATE: I had the wrong URL for the Alfresco-hosted CMIS service. It's fixed now.]

Forrester says 2010 looks good for ECM

jpotts — Wed, 16 Dec 2009 21:11:02 +0000

Forrester has released the results from its 2009 Global Enterprise Content Management Online Survey. Here are a few of the things that jumped out at me…

72% of respondents plan on increasing their ECM investments in the coming year. That’s certainly good news. Of those increasing their investment, the big drivers are content sharing, compliance, search, and automation, which are all typical reasons to roll out a content management solution.

When asked to list the vendors that supply them with ECM solutions, 63% of respondents included Microsoft with EMC a distant second at 35%. (I kind of expected that Microsoft number to be higher). OpenText/Vignette (29%) and IBM (28%) were clustered right around there with a third clump forming around Autonomy/Interwoven (19%), Oracle (17%), and Alfresco (14%). The only other open source ECM players explicitly named were KnowledgeTree and Nuxeo, each with 1%. Almost a third of respondents also listed “Other, please specify” but Forrester doesn’t provide the list of write-ins. I assume it is a bunch of small, niche or homegrown solutions because the usual suspects were listed as explicit choices. Still, this chart and the one following that shows that nearly 3/4 of respondents have 2 or more ECM solutions in-house confirms what we’ve seen in our Optaros clients: Most people haven’t settled on a single ECM provider.

A little more than 1 in 4 of respondents were unsatisfied with their ECM solution. Of those, 41% blamed the solution itself as failing to “live up to expectations” followed by the usual grab bag of non-technical reasons IT projects fail. I would have liked to see a follow-up that dissected the various ways the solution fell short. Was it not able to do something you thought it was going to be able to do? Was stability an issue? Scale? Bad support experience? Or was it just that the beans you were told were magic turned out to be just plain old beans?

As my college stats teacher was fond of saying, “There are three kinds of lies: Lies, Damn Lies, and Statistics,” so take all of this with a grain of salt.

New Tutorial: Getting Started with CMIS

jpotts — Mon, 23 Nov 2009 22:52:42 +0000

I’ve written a new tutorial on the proposed Content Management Interoperability Services (CMIS) standard called, “Getting Started with CMIS“. The tutorial first takes you through an overview of the specification. Then, I do several examples. The examples start out using curl to make GET, PUT, POST, and DELETE calls against Alfresco to perform CRUD functions on folders, documents, and relationships in the repository. If you’ve been dabbling with CMIS and you’ve struggled to find examples, particularly of POSTs, here you go.

I used Alfresco Community built from head, but yesterday, Alfresco pushed a new Community release that supports CMIS 1.0 Committee Draft 04 so you can download that, use the hosted Alfresco CMIS repository, or spin up an EC2 image (once Luis gets it updated with the new Community release). If you don’t want to use Alfresco you should be able to use any CMIS repository that supports 1.0cd04. I tried some, but not all, of the command-line examples against the Apache Chemistry test server.

Once you’ve felt both the joy and the pain of talking directly to the CMIS AtomPub Binding, I take you through some very short examples using JavaScript and Java. For Java I show Apache Abdera, Apache Chemistry, and the Apache Chemistry TCK.

For the Chemistry TCK stuff, I’m using Alfresco’s CMIS Maven Toolkit which Gabriele Columbro and Richard McKnight put together. That inspired me to do my examples with Maven as well (plus, it’s practical–the Abdera and Chemistry clients have a lot of dependencies, and using Maven meant I didn’t have to chase any of those down).

So take a look at the tutorial, try out the examples with your favorite CMIS 1.0 repo, and let me know what you think. If you like it, pass it along to a friend. As with past tutorials, I’ve released it under Creative Commons Attribution-Share Alike.

[Updated to correct typo with Gabriele's name. Sorry, Gab!]

WordCamp NYC, WPBook, WordCamp Boston

jeckman — Sat, 14 Nov 2009 18:41:18 +0000

Here’s the slides from my presentation this morning at WordCamp NYC. It was in the “beginning developer” track so I tried to focus on the overall structure of how the plugin does what it does and the hooks/actions/filters used.

Hard to fit the talk into 30 minutes with time for questions and roadmap – there’s so much more I want WPBook to do – hopefully I can find the time soon.

You Got Your WordPress in my Facebook: Developing WPBook

View more presentations from John Eckman.

I also took the opportunity, naturally, to promote WordCamp Boston, coming January 23rd. See you there?

Looking forward to watching sessions the rest of today and volunteering this afternoon / tomorrow. If you’re here, stop me and say hello.

Top Five Alfresco Roadmap Takeaways

jpotts — Thu, 12 Nov 2009 15:58:34 +0000

Now that the last of the Alfresco Fall meetups has concluded in the US, I thought I’d summarize my takeaways. Overall I thought the events were really good. The informative sessions were well-attended. Everyone I talked to was glad they came and left with multiple useful takeaways.

Everyone has their own criteria for usefulness–for these events my personal set of highlights tend to focus on the roadmap. So here are my top five roadmap takeaways from the Washington, D.C., Atlanta, and LA meetups.

1. Repository unification strategy revealed

Now we know what Alfresco plans to do to resolve the “multiple repository” issue. In a nutshell: Alfresco will add functionality to the DM repository until it is on par with the AVM (See “What are the differences…“). What then? The AVM will continue to be supported, but if I were placing bets, I would not count on further AVM development past that point.

This makes a lot of sense to me. We do a lot of “WCM” for people using the Alfresco DM repository, especially when Alfresco is really being leveraged as a core repository. It also makes sense with Alfresco’s focus on CMIS (see next takeaway) because you can’t get to the AVM through CMIS.

2. CMIS, CMIS, CMIS

Clearly, CMIS is an important standard for Alfresco. (In fact, one small worry I have is that Alfresco seems to need CMIS more than any of the other players behind the standard, but I digress). Alfresco wants to be the go-to CMIS repository and believes that CMIS will be the primary way front-ends interact with rich content repositories. They’ve been on top of things by including early (read “unsupported”) implementations of the draft CMIS specification in both the Community and Enterprise releases, but there a number of other CMIS-related items on the roadmap:

When the CMIS standard is out of public review, Alfresco will release a “CMIS runtime”. Details are sketchy, but my hunch is that Alfresco might be headed toward a Jackrabbit/Day CRX model where Alfresco’s CMIS runtime would be like a freely-available reference CMIS repository (Alfresco stripped of functionality not required to be CMIS compliant) and the full Alfresco repository would continue as we know it today. All speculation on my part.
Today deployments are either FSR (Alfresco-to-file system) or ASR (Alfresco AVM to Alfresco AVM). The latter case is used when you have a front-end that queries Alfresco for its content but you want to move that load off of your primary authoring server. In 3.2, the deployment service has gotten more general, so it’s one deployment system with multiple extensible endpoint options (file system, Alfresco AVM, CouchDB, Drupal, etc.). Alfresco will soon add AVM-to-CMIS deployment. That means you can deploy from AVM to the DM repository. Does it mean you can deploy to any CMIS repository? Not sure. If not, that might be a worthwhile extension.
One drawback to using DM for WCM currently is that there is not a good deployment system to move your content out of DM. It’s basically rsync or roll-your-own. On the roadmap is the ability to deploy from DM instead of AVM. This is one of the features the DM needs to get it functionally equivalent to what you get with the AVM. I wouldn’t expect it until 4.0.

3. Shift in focus to developers

Alfresco WCM has always been a decoupled system. When you install Alfresco WCM you don’t get a working web site out-of-the-box. You have to build it first using whatever technology you want, and then let Alfresco manage it. So, unlike most open source CMS’, it’s never been end-user focused in the sense of, “I’m a non-technical person and I want a web site, so I’m going to install Alfresco WCM”. Don’t expect that to change any time soon. Even Web Studio, which may not ever make it to an Enterprise release, is aimed at making Surf developers productive, not your Marketing team.

Alfresco is realizing that many people discard the Alfresco UI and build something custom, whether for document management, web content management, or some other content-centric use case. To make that easier, Alfresco is going to rollout development tools like Eclipse plug-ins, Maven compatibility, and Spring Roo integration (Uzi’s Spring Roo Screencast, Getting Started with Spring Roo ).

Alfresco has also announced that web scripts, web studio, and the Surf framework will be licensed under Apache and there were allusions to “making Surf part of Spring” or “using Surf as a Tiles replacement”. I haven’t seen or heard much from the Spring folks on this and I noticed these topics were softened between DC and LA, but that could have just been based on who was doing the speaking (see “What do you think of Alfresco’s multi-event approach?“).

Essentially what’s going on here is that Alfresco wants all of your future content-centric apps and even web sites to be “CMIS applications”, and Alfresco believes it can provide the best, most productive development platform for writing CMIS apps.

4. Stuff that may never happen but would be cool if it did

This is a grab bag of things that are being considered for the roadmap, but are far enough out to be uncertain. Regardless of if/when, these are sometimes a useful data point for where the product is headed directionally.

Native XML support. Right now Alfresco can manage XML files, obviously, but, unlike a native XML database like eXist or MarkLogic, the granularity stops with the file. Presumably, native XML support would allow XML validation, XPath and XQuery expressions running against XML file content, and better XSLT support.
Apache Solr. I think the goal here is to get better advanced search capability such as support for faceted search, which is something Solr knows how to do.
Repository sharding. This would be the ability to partition the repository along some (arbitrary?) dimension. Sharding is attractive to people who have very, very large repositories and want to distribute the data load across multiple physical repositories, yet retain the ability to treat the federation as one logical repo.

5. Timeline

Talk to Alfresco if you need this to be precise, but here’s the general idea of the timeline through 4.0 based on the slides I saw:

3.2 Enterprise 12/2009
CMIS 1.0 Release Spring 2010
3.3 Enterprise 1H 2010
4.0 Enterprise 12/2010 (more likely 2011)

Thanks, Alfresco, and everyone who attended

Lastly, thanks to Nancy Garrity and the rest of the team that put these events together. I enjoyed presenting on Alfresco-Drupal in Atlanta and giving the Alfresco Best Practices talk (Alfresco Content Community login required).

I always enjoy the informal networking that happens at these events. There’s such a diverse group of experience levels, use cases, and businesses–it makes for interesting conversations. And, as usual, thanks to the book and blog readers who approached me. It always makes me happy to hear that something on your project was better for having read something I wrote. It was good meeting you all and I’m looking forward to the next get-together.

Django + Alfresco was a winning combination for retailer’s intranet

jpotts — Thu, 05 Nov 2009 20:50:33 +0000

Last week I spent some time with one of our clients talking about what it’s been like to live with their Intranet platform based on Django and Alfresco. The conversation got me really excited about what they’ve been able to do since the original implementation and where they are heading.

The client is a well-known, high-end retailer based in Dallas. About a year ago they engaged Optaros to replatform their intranet from a legacy Java portal product to something more agile. They had seen Alfresco and liked it as a core repository, but needed something for the presentation tier (See “Alfresco User Interface: What are my options?“).

The Optaros team worked with the client to consider many options, including open source Java portal servers. The client felt like they needed something lighter and more flexible than a portal server. They were willing to do a lot of the presentation work themselves in exchange for complete design freedom and yet still be enough of a framework to be highly productive. The winning solution turned out to be Django.

Python? No problem.

I was initially worried that introducing a Python-based framework into a Java shop was going to be a problem but they weren’t married to Java. Our team got them up-to-speed quickly and they never looked back. It also helped that the client’s intranet sites were very communication-centric which matched up well with Django’s newspaper heritage.

Here’s how they use the solution in a nutshell:

Content owners use Alfresco Explorer to upload HTML chunks, office documents, and images, set metadata, and submit content for review. This triggers any number of rules that automatically process the changed content (e.g., creating thumbnails, extracting metadata, converting images to a consistent type, creating PDFs from office documents).
Content owners and reviewers can use Alfresco’s “custom views” to preview the content chunk in the context of the front-end site.
Site designers lay out site pages and create components using the Django template system, CSS, JQuery, and other front-end libraries.
Content publishers use the Django administration UI to map areas on the site to categories, folders, and objects in the Alfresco repository–Alfresco has no idea where or how the chunks are being used. This means the repository tier is truly decoupled from the presentation tier, allowing the client to reuse content across multiple areas of the site and across multiple sites within the enterprise.
Designers leverage a Django tag library to create dynamic areas of a page (e.g., when the page is rendered, retrieve all of the content chunks in this particular category from the repository). Django calls Alfresco web scripts to get and post data. The web scripts respond with serialized Django XML which Django caches and then deserializes into Django objects that the front-end can work with.

Separate concerns, play to strengths

The thing to notice about the Alfresco piece is how it sticks to core Alfresco capabilities: Metadata, rules, search, basic workflows, transformers/extractors, presentation templates, web scripts, DM repository. This is straight out of the Alfresco best practices playbook and aligns the client well with Alfresco product direction. A nice enhancement would be to refactor the Django-Alfresco integration to use CMIS which is something we are considering for the open source version of the integration (Screencast, Code).

Agile intranet, happy team

Since the initial rollout, the client has been able to make changes and roll out new sites quickly and easily thanks to the productivity inherent in the Django framework and the clean separation between the front-end app and the repository. Unexpected benefits the client mentioned were how fast they can add new features to the administrative UI (a core admin UI gets built for you automatically by Django) and the ease with which the development team can stand up a new environment.

The language the client team used to describe their work since the rollout summed it up best. They were using words like “beautiful” and “a real pleasure to work with”. When was the last time you heard those sentiments expressed about a WCM implementation?

Drupal/Alfresco Webinar Redux

cfuller — Wed, 21 Oct 2009 13:18:54 +0000

People want intranets that are fun and easy to use, full of compelling content relevant to their job, and enabled with social and community features to help them discover connections with other teams, projects, and colleagues. IT wants something that’s lightweight and flexible enough to respond to the needs of the business that won’t cost a fortune.

Drupal has been recognized for some time as a flexible platform for building lightweight social applications that go beyond “typical” consumer-facing websites, such as intranets for collaborative teams. There have been several projects over the past few years that have been aimed at making this type of Drupal deployment easier and more user-friendly, most notably, the recent Open Atrium release.

Alfresco makes a great compliment to Drupal because it brings robust robust ECM (Enterprise Content Management), DM (Document Management) and workflow capabilities to the table. With the the emergence of the CMIS standard we now have the glue to put these two greate applications together in a very flexible way. As a result, Optaros, with help from Acquia and Alfresco, has created a CMIS Drupal module and Alfresco implementation of the API that is now in use by several enterprise businesses, including Activision.

On November 12, Optaros’ Jeff Potts and Chris Fuller, in conjunction with Acquia, will present a webinar on how using Drupal and Alfresco can solve many of the technical, interface and adoption challenges faced by organizations that want to improve their intranet experience. Please register at https://www2.gotomeeting.com/register/612744906 and join us to learn more about using these great technologies to build a better intranet.

Alfresco Share microblogging component released as open source

jpotts — Mon, 19 Oct 2009 12:00:28 +0000

Back in February (I know, it’s been simmering on the back burner for too long), I did a couple of screencasts on Optaros Labs showing a demo of Alfresco Share (part 1, part 2). In part 2 of that screencast I showed two custom components: Status and Bookmark. Alfresco made Bookmark obsolete by releasing their own shared bookmarks module for Share, and that’s a Good Thing. I kind of expected them to release a microblog component as well, but they haven’t yet. Well, I finally got around to making ours available, so until a similar feature makes it into the product, feel free to use it in your own projects.

The component is simple: A “My Current Activity” dashlet lets you and your team give a quick blurb about what you’re working on. Another dashlet aggregates all of the status entries from your teammates. A global dashlet aggregates the entries from all Share sites. All status changes automatically show up in Alfresco’s Activity Feed as well.

My Current Activity Dashlet

Unlike Twitter, the status component lets you mark an entry as “done”. When you do that, your current status gets reset and the old entry moves to the archive. So it’s a little more task-oriented than more general purpose, free-form microblogging tools.

Deployment is pretty easy. An AMP gets deployed to your Alfresco WAR, and a ZIP gets unzipped into your Alfresco Share web application. That’s it. No configuration necessary. All of the data lives in the same structure as the other tools in your Share site.

I’ve put the code out on Google Code under a BSD license. There’s a pre-built AMP and a ZIP for download or you can checkout and build from source. There’s one Eclipse project for the repository tier and one for the Surf tier. I’ve tested this on Alfresco 3.2 Community. I’ll test it out on the Enterprise releases when I get a chance. There were some changes in the Activity Feed that I had to deal with and I’m not sure how far back those go so I may have to have version-specific releases.

Have a look and give me your feedback. If you want to dig in and make enhancements, bring ‘em on.

Screencast: Basic Alfresco-Kaltura integration

jpotts — Fri, 16 Oct 2009 15:06:48 +0000

Bryan Spaulding, Media Practice Lead at Optaros, and I have been thinking about lightweight digital asset management and Alfresco. Alfresco can manage any kind of asset, including rich media. It has some built-in functionality for doing image transformations and you can easily integrate with open source solutions like ffmpeg to work with video. But many of our clients need something more, especially when it comes to video.

That’s where Kaltura comes in. Kaltura is a fully hosted video solution that provides full analytics, flexible and customizable players and playlists, and robust back-end CDN and hosting services. You can also download the open source Kaltura Community Edition and run it yourself if you want.

There are a variety of ways Alfresco and Kaltura could work together. We decided to start with a basic integration focused on the Alfresco DM repository. The idea is to use that as a foundation, expanding in the future based on community and client feedback to include deeper functionality for the DM repository or broader integration with other Alfresco products like Alfresco Share and Alfresco WCM.

In this short screencast, I demo the basic CRUD functions the integration provides. You will probably want to hit the “full screen” icon on the Kaltura player to see the detail.

The integration is available as open source. You can download the integration from Kaltura’s community site and use it on your projects, or better yet, expand on it and contribute back the code. The readme that is included with the source includes installation and configuration instructions.