Archive for the ‘cmis’ Category

A bit late, but for those of you following this blog who did not join either the San Diego or the London Alfresco DevCon, here are my 3 presos I gave in both conferences available in Share:

Turnout was great and the event was wonderfully mastered by our beloved Chief Community Officer: regarding my presos, I found a very good general interested public on my Maven + Alfresco Application Lifecycle preso, as the Slideshare searchbox top suggestions seem to confirm :)

Alfresco DevCon and Maven top search in Slideshare :) A couple of other presentations were using Maven and I even heard our mighty VP of Engineering mentioning the magic 7-six lettered word a couple of times in the Engineering QA panel.

New challenges in scalability and complex application management are to be expected with the so long awaited Alfresco 4.x version (BTW, don’t forget to join the 4.o EE launch parties :)

So I think we can expect more VERY juicy news VERY soon in scalability and Maven…once again, stay posted :)

I’m very excited about what’s going to happen and I’m going to participate to next week in my mother country :)

If you did not know (and so should definitely join!), next week we’re holding an Alfresco Developer Conference in a nice venue in Rome!

The DevCon is spread over two days (Tuesday 12th and Wednesday 13th of April) and will be full of technical in depth topics on Alfresco product and application development.

On day 1, we’ll be hosting a full day introduction of Alfresco Fundamentals, in which I’ll be giving quick and effective insights on Alfresco key concepts like Repository, Content Modeling, Architecture & Technologies.

On day 2, the agenda is full of Alfresco stars like our Product Managers Mike Farman & Ben Hagan, giving us a full insight on the new and great evolutions of Alfresco 3.4 (and above) in the Social Content Management era. I will also be giving a talk about latest CMIS (and the recent OpenCMIS 0.3.0 release) evolutions and how you can leverage them with Alfresco.

Most of the event will be held in the English language, but for all my talks I guess we can of course be a bit more flexible and go for Italian :)

So, if you did not do it already, please subscribe to this event and join the most interesting Alfresco technical event and first Alfresco Developer Conference in Italy!

See you there!

undefinedundefined

And almost 18 months after Surf-ing in Munich’s snow, but this time as a presenter, and in the quite warmer venue of Cagliari, I was lucky enough to be invited by Max to speak at the Spring Framework meeting last weekend.I just published the slides about my talk “Spring Surf and OpenCMIS, the dynamic duo”, while, considering my agenda of the next weeks/months, I guess it’ll take a while for me to find a little rest and publish some nice photos of the wonderful Sardinian landscape I’ve visited.Nevertheless (as some German friend of mine like to repeat more than often), stay posted!

Abstract:

Funny little story about open source business models and trends: this story goes about the long time discussed and awaited Alfresco Confluence integration, and goes back of almost one year. Confluence is the Enterprise wiki solution from Atlassian, while Alfresco…well I guess it does not need introductions on this blog :)

Short preamble:

This project started  in June 2009 hosted in Google code as joint open source initiative by Alfresco and an Alfresco pan-european partner,  Sourcesense: originally hosted on Google Code under the name “Confluence Alfresco Plugin“.  The project was originally meant to provide access to Alfresco documents from Confluence macros, and was based on the Alfresco proprietary webscripts ReST API. After a promising initial implementation was drafted, the project has not seen any commits as of Jun 2009: the reason behind this sudden stop was  that this implementation was based on very specific Alfresco APIs, and the rise of an Open Standard like CMIS would have made such an approach an early obsolete product.

Where one seem to stop, another rises from its ashes: as natural continuation of the Confluence Alfresco project, in the very same mid 2009 in Google Code a new project is opened under the, more generic, name of Confluence CMIS Plugin. As the name suggests, the scope of this set of Confluence macros was, not just to integrate Alfresco, but to provide Confluence a more generic support for any CMIS compliant repository: this open source & open standard approach was based on the initial versions of Apache Chemistry Java client, still under heavy development at that time, but already attracted some buzz in the Confluence community.

Present times:

Almost one year has passed since then, and I keep on receiving requests (almost on a weekly basis) from Alfresco partners and customers interested in an Enterprise solution for Alfresco Confluence integration.

What happened with Confluence Alfresco (and its successor Confluence CMIS plugin)?

Looking a bit deeper at the project’s mailing lists you can find some hint of what’s going on:

Sounds a bit like the ant vs grasshopper battle, doesn’t it?  :)
My view:

First of all, I must say I really do hope the two efforts will soon be consolidated into one, both from an open source contributor and also Alfresco business perspective.  Still for now, we’ll have to stick and choose one.

Those who know me already might already be guessing this: at the moment, I quite like the approach of the Confluence CMIS plugin, and not only because you can actually check out the code from Google Code / get snapshot releases NOW and have macros in your Confluence to work against any CMIS repository.

Ah, and also not just because I’m a committer in the Apache project (Chemistry) developing OpenCMIS, which is now used by this plugin :)

The reason is instead that I really do prefer an open approach to ECM, especially about building integrations, and that comes out of the my very personal idea of software development.

IMHO, being software development a process, there’s more to it than just a good mix of high quality code and good sales/marketing skills: to build a successful (and scalable) solution, you need to have a sustainable and lean process backing up the development of your solution, a process where systems and people can interact on standards basis and clear information flows, like the ones a controlled open source process can offer.

Conclusions:

The Confluence Alfresco CMIS integration story, is just one example of how the very same solution can be approached in multiple ways: with no doubt, from my perspective, the CMIS based approach is bound to be superior in terms of longevity and maintainability (thus reliability of the business model).

Also, in order to achieve a much broader target, it might be beneficial to keep it in the open source arena: this way, it might get the resonance and the broader adoption that the Confluence community is waiting to actually start consolidating content in more advanced ECM platforms like Alfresco (or any other CMIS compliant server), based on top notch libraries like OpenCMIS (BTW, we’re working toward a first release out soon).

And don’t get me wrong, I’m not just a Stallmann style fundamentalist: it’s still perfectly possible to develop proprietary (and maybe enterprise specific) extensions which might use a different licensing and business model, and maybe Alfresco specific capabilities. I just believe that for core ECM functionalities and product integration, it’s just always better to stick to the standard (especially after all the work put into the CMIS process).

And that sounds especially reasonable,  if you think that both Alfresco (LGPL licensed) and Confluence (offering free hosting for Open Source projects) have important stakes in the Open Source community and potentially customer/prospects which value the extended benefits of an Open (source + standard) approach.

And if you not convinced yet, I have few more thoughts on what I mean by Open (source and standard) ECM

Part of my daily job at Alfresco is to suggest our customers and partners the best way to integrate and customize the extensible and open standards based Alfresco Content Platform.

The open standard concept is indeed a very general one, as it embraces top down standards (i.e. when a committee of some form is created and the standard follows a formal approval process) and, especially since the rise of Open Source, bottom up standards (or standard de facto, i.e. recognized as standard because of major adoption of a large community and well known benefits).
For example, in the case of Alfresco, I would consider support for JDBC, JSR-168, JSR-170 and more recently CMIS as falling into the former category, while technologies like Spring or architectural patterns like ReST as part of the latter. Another example I’m familiar with which might fall in the latter,  is Apache Maven, which allows to use a standardized process for development, release and documentation of your project, and is used by most J2EE open source projects.

In my opinion, both these classes of standards are equally important to a sustainable development process.  They have to be leveraged and balanced, to allow both a potentially very modular growth in features by standard/clear interfaces, while still ensuring wide adoption thanks to the usage well known technologies and enabling tools.

And in my experiences, it’s only in the Open Source ecosystem that open standards can flourish and get stronger, as key building blocks of the backbone of many open and proprietary applications (thus driving also dependent processes, like resource provisioning and maintenance). For this, I’ve always been advocating to leverage open standards (and possibly open source implementations) in ECM integrations/customizations, both for clear architectural advantages and to also provide sustainability to the whole application lifecycle (and thus to the business model at large $$$$).

So when, almost couple of years ago, Alfresco strongly shifted to CMIS, I basically was a “happy camper”, as Nancy would say :)

I’ve been pushing, waiting, trying, educating and contributing to the standard in order to help as much as I could to have this out and kicking in the shortest time-frame. Biggest achievements of this last 2 years have been, on the personal standpoint, my committership for the Apache Chemistry project (which now provides, amongst others, a complete Java CMIS client called OpenCMIS) and, on the career standpoint, the wonderful chance of joining an Open Source ECM Software company like Alfresco.

Even better: participating to an open source open standard implementation, while working for an open source product company…seems a wordgame,  but now after 2 years of great efforts, it’s now fair to say, at least for the J2EE world, that:

“CMIS is ready and easily usable

At this is because of a few amazing things happened in the last months:

Douglas Adams' Babelisfish

As Dave correctly says,  from now on, I think we should more and more try to build on top of this standard approach (and the simplicity offered by OpenCMIS) to achieve simply reusable content oriented applications.

This new open ECM is a bit like moving on from the Tower Of Babel of one off integrations, to open (standard and possibly source) content development aided by CMIS,  playing somehow the Babelfish (see image for a detailed architecture)  that unlocks your content from the specific repository  details…bringing it to an abstract domain model, ready to be introduced in complex, distributed, scalable content processes. Too poetic? :)
In other words, this open ECM it’s not just merely about open standards and/or open source products adoption: it’s more like a new way of envisioning content applications based on both the benefits of open standards and of the open source development process, at technical and communication levels.
After all, same as when design patterns were introduced they drastically changed the way we talked and designed software, we should exploit the great momentum of CMIS to start “talking the same content language”.

This is true for product vendors (which are rapidly offering support for the standard), but also for System Integrators and community members which might end up (finally!!!) building once and use (sell) everywhere.

And so (possibly also because I’ve been attending a Rage Against the Machine concert lately, my last quote and public call for action cannot be any different than:

“Content Workers of the World, Unite (under CMIS) !”

As promised, just a brief heads up on the quite few changes ongoing in the Maven Alfresco Lifecycle project which is now supported by the Alfresco Community Maven repository.  Also I managed to pull out a new version of the Cmis Maven toolkit against the new repository.

Proceeding with order, first of all, I released today a new version (1.1.0) of the maven-alfresco-lifecycle package with the main interesting news (full changes report):

The long Maven Alfresco marathon was then completed by the release of version 1.0-beta-2 of the CMIS 1.0cd04 Maven Toolkit, pointing to the new Maven repository. No actual functionality was modified and it keeps on working happily (by default against http://cmis.alfresco.com) using the latest snapshots from the Chemistry AtomPub TCK trunk. I updated the documentation on the Alfresco wiki as well.

I hope this really helps as it’s just *not that* funny to go over those growing many documentation files to change repos again, so any edit or error you guys can spot in the docs === a beer on me when you seem me :)

Though I first have to apologize to the end users of this build, promising this is the last time this project moves hosting.
Now everything is consolidated, content as artifacts, as in the pure ECM spirit. And with a promising Share archetype to work and customize it productively.

Eager to hear your feedback (curious about the Share archetype), and especially at my Tech Talk on Maven and Alfresco

…don’t be shy :)

Today is a shiny day in my humble open source geek existence: after about 9 months after having been awarded the Apache Chemistry committership, I finally did my first ASF code commit.
About the slowest ever…

When tweeting about it, I go this interesting consideration by my friend and ex-colleague Mario :

@mindthegabz Congratulations! 9 months for a commit is like a childbirth…

While I tend to agree on the quite same importance of  having a kid and doing an Apache Commit :p ,
does this also imply I should start seriously thinking about a larger family? :)

Don’t see it mentioned anywhere in the New Committers guide, am I missing something ? :)

CMIS is cool indeed, and especially working on it with Open Source tools like Alfresco, Maven and Chemistry can result in quite a bit of fun.

I’ve been working quite a lot lately on producing some sample and training material for the coming Alfresco meetups (tomorrow I’ll be presenting the CMIS Master class  live from Madrid), and so I decided to mix and match the two things I can do best:

  • Using my beloved Apache Maven
  • Using the Chemistry AtomPub TCK (former Alfresco CMIS TCK) that we contributed to ASF to provide high level access to the CMIS ReST API

This effort, which I’ll probably heavily use in the next days Master Classes and training session, turned out to be quite productive as in a couple of days of work I was able to:

  • develop a Labs framework which wraps Chemistry TCK embedded CMISClient
  • provide an easy CMIS 0.62 application(s) scaffolding platform using a Maven multimodule project
  • produce and release a Maven archetype which is now hosted our partner Sourcesense repositories ( big thanks go to this folks for being always supportive with their Maven maven infrastructure) and can be used as CMIS launchpad / labs / toolkit

Trying it is very easy, due to Maven archetypes power, and you can have the full Labs toolkit downloaded and installed on your by just selecting ‘cmis-master-labs-archetype‘ in the options of the command below:

EDIT

mvn archetype:generate 
-DarchetypeCatalog=http://maven.alfresco.com/nexus/content/repositories/releases/archetype-catalog.xml
mvn archetype:generate 
-DarchetypeCatalog=http://repository.sourcesense.com/nexus/content/repositories/alfresco.public.releases/archetype-catalog.xml

mvn archetype:generate -DarchetypeRepository=http://repository.sourcesense.com/nexus/content/repositories/alfresco.public.snapshots -DarchetypeGroupId=org.alfresco.enablement.codecamps.cmis -DarchetypeArtifactId=cmis-master-labs-archetype -DarchetypeVersion=1.0

This will create a multiproject structure ready for use. You’ll just need to configure (in a single sourced fashion for the whole suite)  the CMIS endpoint properties in the main POM, by editing the following properties:

<!-- SINGLE POINT OF CONFIGURATION FOR CMIS ENDPOINT -->
<properties>
<!-- Configure here the CMIS endopoint For the whole suite -->
<cmisserviceurl>http://192.168.154.128:8080/alfresco/service/api/cmis</cmisserviceurl>
<cmisusername>admin</cmisusername>
<cmispassword>admin</cmispassword>
<cmistracerequests>true</cmistracerequests>
<cmisvalidateatom>true</cmisvalidateatom>
</properties>

All the nice tracing and validation features of the Chemistry TCK are exposed, once that you configured the POM to point to a proper CMIS 0.62 compliant server (e.g. Alfresco, and an Ubuntu Alfresco VM is available here for this purpose). Specifically the toolkit offers 3 Maven submodules

  • cmis-support –> Support JAR which wraps Chemistry TCK CMISClient
  • cmis-query-webapp –> Very basic SpringMVC webapp querying a CMIS repository and showing results/entries
  • cmis-lab-atompub-binding –> Learning lab on how to import data in Alfresco (complete class in the solution folders)

and a lab-solutions folder.

Using it is pretty straighforward. A simple

mvn install

will test the support against the provided configuration, while entering the cmis-query-webapp folder and running

mvn jetty:run-exploded

will result in the (quite ugly) but functional CMIS Query interface you can see below:

CMIS Query Webapp

using a simple three tiered architecture like the one that follows:

CMIS Query Webapp architecture

Lastly entering the lab-atompub-binding folder and running

mvn test

will run the sample JUnit empty test for the data import lab. Solution (real Test class) is to be found in the labs-solutions  folder.

It’s a beginning but I believe it’s a very nice tool to overcome the somehow still steep learning curve around CMIS, so I warmly suggest you start installing the VM and the archetype and play around with it, and even use it as start for your integration/contribution projects. Especially if you are going to attend Alfresco meetups this month. I’ll surely post the Labs slides later this month, so stay posted!

EDIT

The CMIS 1.0 Public Review compliant toolkit (working against Chemistry AtomPub TCK Trunk 1.0) is available on the Sourcesense repository and it’s added to the remote catalo mentioned in the previous command.

As a side note, at the moment this toolkit provide support for CMIS 0.62 while http://cmis.alfresco.com is Alfresco supporting CMIS 0.70: I’m planning to update the archetype (just a mere Maven dependency :) ) to use the HEAD version of Chemistry TCK that is supporting 0.70.

Feedback welcome as usual!

Hope this really helps :)

My first real involvement in Chemistry definitely deserves a first post on the subject ;)

Lately I’ve been involved into refactoring the Alfresco CMIS Test Harness into an external Tck (Test Compatibility Kit) module to contribute to the Apache Chemistry. At the moment it’s mostly focused on the AtomPub part (including an Apache Adbera extension), but being based on Apache Maven standards should be fairly easy to scale out to WebServices binding testing.

This would be this first real contribution from Alfresco to the Chemistry project, where me and David Caruana have the luck of being involved as committers. At the moment the code for the will-be-called chemistry-atompub-tck is still hosted under the Alfresco contrib SVN space as still to be completed, but already offering quite some nice functionalities to test the compatibility of your server to the CMIS 0.6.2 standard.

The code (which was already in Alfresco and kept up to date to the CMIS standard directly by David) is now almost ready for contribution as it’s completely decoupled from Alfresco and uses a standard Maven build process (Junit + Surefire) to run compatibility tests against an existing (and running) CMIS server.

So, running a plain :

mvn test

will run all Junit tests against the specified serviceUrl with specified the username and password, using Maven POM properties as configuration mechanism. Additional configuration can be done in the POM to trace HTTP request/response conversation (useful for debugging purposes), and to configure some behaviors of the HTTP client.

In addition to that, due to the mighty Maven power a small addition to the previous command:

mvn test site:run

will allow you to point to anembedded Jetty server which publishes the test reports and shows errors and exceptions (amongst all the other nice Maven site features).

The idea at the base of this contribution is that this TCK can be used to test virtually any CMIS implementation and Maven profiles provide us a nice way to aggregate the full test fixture and publish the result in a nicely aggregated fashion. In fact, I started defining a profile called ‘alfresco’ which once run with:

mvn test -Palfresco

will configure the TCK to run against an Alfresco provided CMIS reference URL (or to do any Alfresco specific pre-requisite steps, like downloading it, installing a custom model and run it in Jetty for self contained testing).

In the same way I’d like all the other open source vendors involved in Chemistry to maintain their own profile which will serve as community reference for the CMIS readiness of a specific platform. Likewise we could setup ‘sharepoint’ or ‘documentum’ profiles to test existing public instances of those CMIS implementors, to always be up to date with their state of the art.

This will, of course, make much more sense once integrated in Chemistry but it’s already fully functional against the CMIS 0.6.2 standard and might be worth a try already. And if you feel to participate to the testing game, why don’t you make a CMIS server instance available and contribute the few lines of POM configuration to the project, filing a nice and easy JIRA issue?

Too much of a salesguy ? :)