A little over a month ago, I encouraged my readers–many new from the Day Software (now Adobe) community via the Ignite conference in Berlin–to download and leverage Adobe Enterprise Café.

…the Café is hard at work to integrate the Day community as well. However, you don’t need to wait for that new version of Café; you can install Café today and when the Day community is integrated, you’ll receive that update the next time you launch the Adobe AIR application.

Hopefully you’re already receiving value from Café. If you held out for the Day community integration with Café, that day has arrived.

Presenting Adobe Enterprise Café 1.6!

Update 7/29/2011: Now that the Adobe® Digital Enterprise Platform (ADEP) has been announced, I recommend that you upgrade to Adobe Enterprise Café 1.8, which features a new ADEP community that is the combination of the previous LiveCycle and Day Communities.

For technical insights on ADEP, please follow the ADEP category and/or ADEP tag herein. Thanks.

Thanks to everyone at Day Ignite Berlin 2010 who came to the technical track session that I presented this afternoon. In order to keep the conversation going, I’ve uploaded this presentation as follows:

During this presentation I recommended that you consume my “Realizing great customer experiences with LiveCycle ES3″ presentation from Adobe MAX 2010, if you’re interested in more details about the architecture and capabilities of LiveCycle ES3. You will find that presentation here.

I also asked you to consider downloading and installing Adobe Enterprise Café. Café, as we like to call it in Adobe, helps you stay in touch with the enterprise community, receive news, find information and aggregate content related to Adobe LiveCycle ES (Enterprise Suite), Acrobat, Connect, ColdFusion, the Adobe Flash Platform, and (since its v1.5 release) the Omniture community. Targeted at the general developer ecosystem, Café is the one tool you need to search across the entire community knowledge base and stay in touch with the Adobe teams. Furthermore, the Café is hard at work to integrate the Day community as well. However, you don’t need to wait for that new version of Café; you can install Café today and when the Day community is integrated, you’ll receive that update the next time you launch the Adobe AIR application.

When I presented this session with Alex Choy in Chicago, Irina Guseva of CMS Wire published her thoughts on the session: “Apps as Content, or How Day and Adobe May Fit Together.”

Thanks to everyone at Adobe MAX 2010 who came to the session that David Nuescheler, Roy Fielding and I presented. If you weren’t able to attend our session, it’s provided below.

Roy kicked off the discussion by talking about open development and how open development is critical to architecture. David followed Roy by showing how open development principles have been powerfully applied at Day to its products like CQ5, providing live demonstrations to our audience. I wrapped up this discussion by relating WCM and Day content infrastructure (e.g. Sling and CRX) to Adobe’s CEM platform and specifically to LiveCycle RIA. (For more detail on LiveCycle RIA and other aspects of the LiveCycle ES3 release, which is currently under development, please see my previous post.)

In order to keep the conversation going, I’ve uploaded this presentation as follows:

Update 11/5/2010: You can now watch and listen to this MAX session online (i.e. in synchronized fashion).

Update 12/3/2010: Jayan has done a nice job of rounding up LiveCycle-flavored MAX sessions, including this one, here.

Thanks to everyone at Adobe MAX 2010 who came to the sessions that I presented. I enjoyed the interactivity during after after the presentations, especially listening to your thoughts on how Adobe CEM will enable you to realize your own customer experience vision as well as the growing expectations of your prospects, consumers, customers and clients.

In order to keep the conversation going, I’ve uploaded this presentation as follows:

Realizing Great Customer Experiences with Adobe® LiveCycle® ES3 – Craig Randall

Whether you were able to attend MAX or not, I encourage you to check out MAX 2010 on Adobe TV (e.g. here are the keynotes). Please also visit the MAX 2010 session catalog to browse all sessions and download presentations of interest.

Update 11/5/2010: You can now watch and listen to this MAX session online (i.e. in synchronized fashion). It appears that the good folks at MAX decided to post the slides and recording that corresponded to my first delivery (on Monday during MAX). While that session went well, I did receive some feedback that I incorporated into a revised deck that was also recorded (on Wednesday during MAX). Personally, I liked the latter content and delivery better than the first, and that is what is provided here in this blog post, above.

Update 12/3/2010: Jayan has done a nice job of rounding up LiveCycle-flavored MAX sessions, including this one, here.

Thanks to everyone at Day Ignite Chicago 2010 who came to the technical track session that Alex and I presented–especially those who stood the entire time in a packed room.

In order to keep the conversation going, I’ve uploaded this presentation as follows:

We’re very excited at Adobe about the opportunity to work with those at Day Software as fellow colleagues. By working together with you, we believe that great things will emerge from the unified delivery of content plus applications.

P.S. If you’re not already watching the #dayignite tweetstream, why not?

Update 10/18/2010: Irina Guseva published her thoughts on this presentation on CMS Wire: “Apps as Content, or How Day and Adobe May Fit Together.”

Update 10/22/2010: Presentations from Day Ignite Chicago 2010 are appearing here. Presentations that will also be delivered during Day Ignite Berlin 2010 won’t appear on Slideshare until after both events have concluded. (That being said, you can see a thorough write-up of David Nuescheler’s presentation here.) Event photos from Chicago are here.

Update on 10/27/2010: The message first delivered in Chicago around the unified delivery of content and applications was expanded upon in Los Angeles at Adobe MAX 2010, and that presentation is now available here.

Note: If you’re visiting this blog from the Adobe LiveCycle Developer Center or from the Adobe LiveCycle Blog, welcome to my musings. You’re invited to tell me what you want to know about LiveCycle via a comment. Thanks in advance!

This longer-than-usual post is intended to help customers understand why the new application model exists in LiveCycle ES2 and understand how to migrate LiveCycle ES assets into ES2 assets, based on business value into doing so. It is meant to complement, not reiterate, other content already published concerning the application model (e.g. the section on migration process, below, is just an example meant to whet the reader’s appetite for more detailed demonstration/conversation elsewhere).

So, without further ado…

Table of contents:

1. Introduction
2. Application model principles
3. Conclusion
4. Additional resources

Introduction

When Adobe LiveCycle ES2 released, major advancements and changes occurred in several areas of application development. The purpose of this white paper is to explain these advances specifically in the context of migrating existing LiveCycle assets into the new ES2 application model. However, before the migration process is described step by step, it’s important to understand the new model, why it is exists and when it should be leveraged.

The most notable changes to application development in LiveCycle ES2 are as follows:

• LiveCycle Applications
• Versioning
• Far and Near References

All new development work in LiveCycle ES2 occurs in LiveCycle Applications.[1] A new Applications view replaces the Processes and Resources views in LiveCycle Workbench ES2 as the primary view for application development. Both Processes and Resources views remain to support upgraded LiveCycle assets that have not yet been migrated to LiveCycle Applications.

LiveCycle Applications contain processes, forms, guides, data models, events, fragments, images, DDX files (Assembler document service), DSC’s, etc.[2] A LiveCycle Application is a container of design-time assets. When a LiveCycle Application is deployed, services are delivered into the runtime, and at this point a particular service’s implementation becomes hidden from the consumer (e.g. there is no “File | New -> Service” that emits a service object in LiveCycle). Consumers continue to discover services via the LiveCycle Service Registry.

It is important to understand that from now on when you do something in Workbench the first thing you do is “File | New -> LiveCycle Application” and that the Application is the container for all your application assets.

A LiveCycle Application is the basis for a hardened, discrete versioning model in LiveCycle ES2. That is, application assets do not have versions of their own; they inherit the version of their parent LiveCycle Application. These version numbers are immutable, meaning that they do not change even when the application is deployed on different LiveCycle systems. In LiveCycle ES an edit/save gesture on an application assert could result in the creation of a new version of that asset; however, in LiveCycle ES2 such gestures will not–version is defined solely by the hosting application.

A LiveCycle Application is the context for how asset references are maintained. An asset referring to another asset in the same LiveCycle Application uses a relative near reference. When an asset refers to an asset in a different LiveCycle Application then it is a far reference. Far references are required to state LiveCycle Application name and version (e.g. repository:///Applications/NewCustomers/1.0/Loan/Forms/request.xdp).

Figure 1. Applications, Assets and References

In the above figure, there are two applications (i.e. App1 and App2) and a total of three application assets (i.e. A, B and C). The line between A and B represents a near reference (i.e. wholly contained by App1). The line between A and C represents a far reference (i.e. a reference that spans from one application to another application–specific version).

In the above figure, App1 and App2 can be versioned (i.e. 1.0, 1.1, 2.0, etc.); however, A, B and C cannot be versioned apart from their containing LiveCycle Application.

Application Model Principles

So, why did LiveCycle ES2 usher in a new application model, and why should you want to upgrade to leveraging it?

In LiveCycle ES, there were services/processes, events, forms and Document Service Components (DSCs). Each object had distinct user interface with different semantics for how the object could be edited, locked, activated, secured, versioned and exported. Conceptual information that the user acquired while using one subsystem was not transferable to the other subsystems. One of the design goals of the LiveCycle ES2 application model was to normalize these behaviors and provide a consistent user model across the managed objects.

The LiveCycle ES2 application model provides hooks at strategic points in an asset’s runtime. The ability to transactionally deploy a collection of assets and the ability to intercept the runtime lookup of a named asset both represent key indirection points that can be leveraged in future versions of LiveCycle.

The LiveCycle ES2 application model enforces a consistent persistence model for the design-time assets. This, in turn, provides the foundation for supporting disconnected mode (offline or occasional connectivity), SCM integration and intuitive experience in Workbench (e.g. login/logout, open/save).

Your confidence during migration is of utmost importance. The LiveCycle ES2 application model addresses migration confidence by enabling existing investments to continue running in a “bug compatible” manner. Maintenance of existing systems can involve evolving an existing system on an as-needed basis.

The application model in ES2 supports two types of changes: semantic and non-semantic. Given that an application is a composition of assets, change can refer to the set of assets in the application and/or to the assets themselves—both their content and their associated metadata.

A non-semantic change represents an update that does not provide any new functionality over prior versions but rather represents an incremental refinement. Bug fixes and patches are good examples for a non-semantic change. A non-semantic change never requires consumers to be aware of the change. Non-semantic changes can be imposed by the producer on all of its consumers without requiring the participation of the consumer.

A semantic change represents an update that will introduce new capability above what is available in pre-existing versions. It is possible that a semantic change will necessitate that the consumers adjust the way that they interact with the objects. A semantic change must be explicitly requested by consumers, it is never implicitly forced upon them by the producer.

Example migration to ES2 application model

So, now that you have a better understanding of a LiveCycle Application and the new application model in LiveCycle ES2, let’s walk through the process of migrating a LiveCycle ES (8.x) process to a LiveCycle ES2 (9.x) process:

1. Deploy the LiveCycle ES LCA as LiveCycle Archives (8.x) (Compatibility mode).
   • The LiveCycle ES processes will run as-is on LiveCycle ES2 as LiveCycle is backward-compatible. If your goal is to simply move the running content to an ES2-based server (without taking advantage of any new capabilities) you are done.
   • If you want to leverage native ES2 functionality, you will need to follow the rest of these migration steps in order to convert the LiveCycle ES process to LiveCycle ES2 process. Converting the process will result in a service name change since the LiveCycle Application name (namespace), version, etc. become part of the service name in LiveCycle ES2.
   • Best practice: If you are adding new resources to the application the recommendation would be to do a full migration and import all assets into the new application, resetting the deployment identifiers. Mixing and matching legacy ES resources and the new ES2 application model is not recommended.
2. In Workbench, create a new application (e.g. MyApplication).
   • Application name forms a namespace for assets therein.
   • You can optionally create folders within the application to specialize this namespace further.
   • For example, your development team may have particular standards for organization (e.g. based on asset type, based along functional lines, etc.).
   • In this particular migration, we’ll create a “processes” folder to receive the imported ES process assets.
3. In Workbench, right-click on MyApplication/1.0/processes and select Import. In the dialog shown, select Process and click Next. In the next screen, select the LiveCycle ES process from its LiveCycle ES category. Click Finish.
4. The LiveCycle ES process will be added to the LiveCycle Application (i.e. MyApplication). Please note that this is a copy of the original process.
   • The service name of original process is the process name itself; however, the service name of the new process is ApplicationName/processes/ProcessName.
   • Assets in ES lived apart from a namespace (i.e. unqualified services at runtime). ES assets in ES2 operate in a global service namespace (implied) at runtime. Native ES2 assets operate in application-scoped namespaces.
5. If the original LiveCycle ES process has dependencies on other LiveCycle ES sub-processes, the new LiveCycle ES2 process will also have the same dependencies (i.e. LiveCycle ES2 process depending on LiveCycle ES processes). Therefore, in order to create a self-sufficient LiveCycle ES2 LCA containing processes with the same functionality, we need to identify and reset these dependencies. That means finding each dependency, visiting it and pointing it to something new.
   • In order to point a dependency at something new, the desired dependency target must exist in the application.
   • Best practice: create self-contained applications.
6. To remove dependencies from other LiveCycle ES processes, we’ll have to repeat steps #3 to #4 and import all those processes under the same LiveCycle Application (e.g. ApplicationName/processes/SubprocessName).
7. After importing all processes under the LiveCycle Application, we’ll have to edit all the processes individually in order to replace all the sub-process activity with the new processes.
   • Consider the following example: Process A uses process B (LiveCycle ES).
     • Both ES processes are imported into the LiveCycle Application, which results in processes A’ and B’ (LiveCycle ES2).
     • However, process A’ (LiveCycle ES2) still uses process B (LiveCycle ES).
     • We edit A’ and replace activity B with B’, using the same input/output parameters.
   • This step requires manual editing of all processes using sub-processes, which is time-consuming and can be error-prone without sufficient attention to detail.

This example is simply focused on process asset migration, but, as previously noted, there are several other application asset types that may be migrated.

Conclusion

Hopefully this paper has been helpful to your understanding of why there is a new application model in LiveCycle ES2 and how to take advantage of this capability with your LiveCycle ES investments in mind.

The LiveCycle team continues to work on enhancing migration support for its customers (e.g. increased automation), and it appreciates your feedback.

Additional Resources

For a more detailed dive into the process of migrating LiveCycle ES applications and assets to LiveCycle ES2, please consider the following content:

• Migrating an Application from Adobe LiveCycle ES to ES2 (guided demonstration by my LiveCycle colleague Seth Reilly)
• Leveraging Legacy Solutions in LiveCycle ES2 (document)

Footnotes

1. LiveCycle Application should not be confused with LCA, which stands for LiveCycle Archive. LiveCycle Archives continue to provide the ability to export an application along with its assets (i.e. variables, images, documents, etc. since ES, service endpoint configuration and security since ES Update 1, etc.). Asides: (a) legacy LCA’s are still supported in ES2 (i.e. it’s possible to create/import them), and (b) there are two kinds of native ES2 LCA’s: patch (a specifically selected set of assets) and full (one or more applications where all content from the application is involved–no need to explicitly enumerate assets).
2. These contained objects are called assets (i.e. application assets).

Today we launched a new EMC Documentum developer-oriented community within the EMC Community Network. Front and center is the new developer edition of the EMC Documentum ECM Platform.

So, what does this developer edition include? We believe it includes a lot of goodness for the development of content-enabled applications.

• First of all, free software for developers
• A new one-click installation process for the core of the EMC Documentum ECM Platform
• xDB and new XML components – please visit the just-launched XML Technology Developer Community for more details about our native XML database and other technologies
• Integration between the resulting development environment and online community resources and support mechanisms – think of this as a starting point and means to the ends you want to pursue, not an end in itself

Essentially, we’re trying to provide a low-touch, DIY experience. That being said, by integrating your local installation to an online community, the developer edition enables you to reach out to fellow developers and EMC employees as your pursuit your content management development interests grows. For example, you’ll find a range of white papers, documents and videos, as well as sample code in, for example, Java and C# (.NET). Topical tutorials available online are drawn from our Education Services library.

So, what is the process to obtain the free developer edition? We hope that it’s straightforward.

1. Browse here and login into ECN/EDN
2. Navigate here and complete a short (less than 30 seconds) registration form. Click the “Continue” button to proceed to the download site. (You may need to add ecn_communications@emc.com to your email safe senders list so as not to miss messages from that address (i.e. have them interpreted by Outlook as junk).)
3. Navigate the EMC SubscribeNet links to arrive at the FTP download (or HTTPS-based download, if you prefer). Note that the download is a bit more than 1.73 GB and represents a Zip archive, which means that you should ensure adequate disk space to extract, deploy, etc.
4. Commence your download.

In a follow-up post, I’ll walk you through the installation experience and how to leverage the version of DFS that comes with the developer edition. BTW, if you’re too anxious to dive in and can’t wait for my post, go for it! There is an online getting started guide as well as an online tutorial for building your first application.

Cheers!

Update 5/20/2009: Well, I’m about to take a much needed vacation, and I have yet to follow-up with a walk-thru post. So, I wanted to at least provide some details here as to what this software requires system-wise. System requirements are as follows (and are displayed in the initial installer screen):

• No Microsoft SQL Server or SQL Server Express installed [1]
• No other Documentum software installed [2]
• Microsoft .NET 2.0 or higher [3]
• Browser with Sun JRE 5.0 update 16 or higher [4]
• Minimum of 3 GB RAM (4 GB RAM is recommended)
• 5 GB of free disk space [5]
• Intel x86 CPU
• Operating system–again 32-bit only for this release–is one of the following: Windows XP SP3, Windows Server 2003 SP2 or Windows Server 2003 R2 SP2
• You must be logged in as a member of the Windows Administrators group, but not necessarily as Administrator

Notes:
[1] Be aware that if you already have Visual Studio (e.g. 2005 or 2008) installed on your target machine, you may need to first uninstall the version of SQL Server that may have been installed with the IDE. If you are running Windows SharePoint Services or UDDI on your target (Windows Server 2003) machine, you may also need to see what embedded database is supporting these services before proceeding with this developer edition installation.
[2] Be sure to understand where you may still have Documentum-related configuration files on disk (e.g. dfc.properties, C:\Documentum, etc.).
[3] Microsoft .NET Framework 3.0 is required for WCF-based consumption of DFS endpoints; so, I recommend .NET 3.0, which includes (requires as its foundation) .NET 2.0. .NET 3.5 is also supported by DFS, if you prefer to leverage WCF “v2.”
[4] This is supported by Webtop and DA.
[5] Keep in mind that, as I noted above, the Zip archive download is a bit more than 1.73 GB. The total size of its extracted contents is not that much larger, but you’re also starting to approach 4 GB; so, I recommend that you have 10 GB free disk space in order to complete the installation with room to spare before cleaning up the extracted bits and the original archive to reclaim that 4 GB.

…and, welcome, CMS Watch readers!

Update 7/16/2009: Be sure to run Windows Update after installing DevEd. Typically, you’ll need to apply SQL Server 2005 SP3. Note that if you upgrade a DevEd environment from 6.5 SP1 to 6.5 SP2 (via uninstall-reboot-install) that you should still run Windows Update after your upgrade, and you may need to re-apply SQL Server 2005 SP3.

When upgrading a DevEd environment from 6.5 SP1 to 6.5 SP2, I also recommend that following the uninstall and reboot, that you confirm C:\Documentum and C:\Program Files\Documentum are empty before you proceed to install the newer DevEd.

Finally, if you’re reading this blog but not the installation guide, please note that you should uninstall DevEd via Start | Programs | Documentum | Uninstall, not via Add/Remove Programs under Control Panel.

Laurence Hart was kind enough to pick-up my previous post on content-enabled applications and add his thoughts to the subject, especially concerning the role CMIS can play.

From my first post: Content-enabled applications should facilitate the convergence of content, collaboration, interaction, and process.

I agree with Laurence (aka JaneDoePie) that content is an enabler, not the center. All content-enabled applications “should be shaped to work with and enhance the process the users use to perform their work.”

Laurence offers case management as his favorite, generic content-enabled application in order to further ground the point that success is determined by the combination of content, user experience (interaction, more than just UI, IMHO) and process (e.g. collaborative workflow).

I’m in the middle of reading Subject To Change, and already I’ve found its message highly relevant to the subject of content-enabled applications. For example, the book focuses on experience strategy and how to develop organizational empathy where the target users of your products or services are concerned. Specifically, in the case of case management, the book would argue that you, as case management application architect/designer, need to actually observe case workers in their native setting to appreciate how case management really works (or doesn’t). Go beyond theory and someone else’s analysis. Experience business activity firsthand in order to model reality into your solution.

Recently as part of the Case Management Solution Framework xCelerated Composition Platform (xCP) released for D6.5 SP1, a sample application for grants management was shipped that illustrates how Process Suite components can be used to build case-based, content-enabled applications. You can download this package from Powerlink (authentication required). The easiest way to run this sample application is to install it using the express installer, which will install all the right components (with their compatible versions) and the DAR file. You can also download the express installer from Powerlink (authentication required).Please see the update below for the correct link.

A goal of a solution framework is to make it easier to build content-enabled applications such as those for case management. A solution framework should allow you to invest more time in becoming empathic in order to ship solutions that resonate well with your users and drive more efficient business as a result.

In this response, I wanted to focus on empathy’s role. Separately, I plan to pick up the CMIS angle raised by Laurence. Thanks in advance for joining our discussion online…

Update 5/1/2009: A PM colleague pointed out to me that the link to the “one click” installer that takes one from state “zero” (i.e. Windows but not database) to state “ready for proof of concept” is as follows: https://emc.subscribenet.com/control/dctm/download?element=2193203 (authentication required). Cheers!

If you’re a .NET-based consumer of Enterprise Content Services (e.g. those offered via Documentum Foundation Services) and you experience a Windows Communication Foundation CommunicationException having to do with MaxReceivedMessageSize, you may be interested in the details of this post. This post applies both to direct-to-WSDL consumers and also to consumers that leverage the DFS productivity layer for .NET. Guidance herein has more to do with WCF in general; however, it will be offered in a ECS/DFS context.

Depending on the size of incoming messages from services to your application, you may discover the need to increase the maximum received message size. For example, your application experiences the following exception raised by WCF:

System.ServiceModel.CommunicationException : The maximum message size quota for incoming messages (65536) has been exceeded. To increase the quota, use the MaxReceivedMessageSize property on the appropriate binding element.

An example of exceeding quota could be application requests that result in data package-based responses with a large number of data objects and/or a set of data objects with significant metadata and/or content (e.g. ObjectService.get).

If you implement a direct-to-WSDL consumer of this service using Visual Studio and WCF’s Add Service Reference designer, you will by default introduce a per service binding application configuration file into the overall solution. Therefore, to declaratively increase the maximum received message size, you will edit app.config by focusing on increasing the value of the MaxReceivedMessageSize attribute on the appropriate (named) binding element from the default value in configuration as follows:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <bindings>
      <basicHttpBinding>
        <binding name="ObjectServicePortBinding" closeTimeout="00:01:00" openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00" allowCookies="false" bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard" maxBufferSize="65536" maxBufferPoolSize="524288" maxReceivedMessageSize="65536" messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered" useDefaultWebProxy="true">
          <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384" maxBytesPerRead="4096" maxNameTableCharCount="16384" />
          <security mode="None">
            <transport clientCredentialType="None" proxyCredentialType="None" realm="" />
            <message clientCredentialType="UserName" algorithmSuite="Default" />
          </security>
        </binding>
        . . .
      </basicHttpBinding>
    </bindings>
    . . .
  </system.serviceModel>
  . . .
</configuration>

As in the case of a direct-to-WSDL consumer, a productivity layer-based consumer of the DFS Object service may also need to declaratively increase the value of MaxReceivedMessageSize more compatible with actual runtime requirements.

In the etc\config directory path of your local DFS SDK you should find an example App.config file. Please note that this app.config file is oriented toward productivity layer consumers, not direct-to-WSDL consumers via WCF. That being said, the same binding attributes apply to a solution here, too. The difference is how the bindings are declared in app.config.

The productivity layer oriented declaration names a single binding, DfsDefaultService, to act as the binding for all DFS services, except for DFS runtime services, which have separate, named bindings declared. So, Object service gets its (WCF- based) binding configuration from the “DfsDefaultService” binding…and so does, for example, Query service.

To declaratively increase the maximum received message size in productivity layer oriented app.config, you will most likely edit the MaxReceivedMessageSize attribute on the “DfsDefaultService” binding element from the default value in configuration as follows:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  . . .
  <system.serviceModel>
    <bindings>
      <basicHttpBinding>
        . . .
        <binding name="DfsDefaultService" closeTimeout="00:01:00" openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00" allowCookies="false" bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard" maxBufferSize="1000000" maxBufferPoolSize="10000000" maxReceivedMessageSize="1000000" messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered" useDefaultWebProxy="true">
          <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384" maxBytesPerRead="4096" maxNameTableCharCount="16384" />
          <security mode="None">
            <transport clientCredentialType="None" proxyCredentialType="None" realm="" />
            <message clientCredentialType="UserName" algorithmSuite="Default" />
          </security>
        </binding>
      </basicHttpBinding>
    </bindings>
  </system.serviceModel>
</configuration>

You may notice that the DFS SDK-based app.config binding element attribute values differ from direct-from-WCF defaults (i.e. maxBufferSize–1000000 versus 65536, maxBufferPoolSize–1000000 versus 524288, and maxReceivedMessageSize–1000000 versus 65536). This is simply a change to lessen the likelihood of encountering WCF CommunicationExceptions having to do with MaxReceivedMessageSize values.

One technique you can employ to determine what a reasonable MaxReceivedMessageSize value should be for your application is to set the value of your binding attribute/property to the absolute maximum in order to profile actual runtime message size using a web debugging proxy like Charles or Fiddler. That is, temporarily set MaxReceivedMessageSize to 2147483648 (i.e. Int32.MaxValue), pass your SOAP messages through, for example, Charles via port forwarding, review response message content length values, and reset your default runtime MaxReceivedMessageSize value accordingly.

If you prefer to take a declarative approach to WCF binding configuration for your application but you’re concerned about a user setting the value too low, you can always interrogate values at runtime in order to ensure that they’re sufficient.

For example, a productivity layer-based client could do as follows:

System.Reflection.FieldInfo appConfigInfo = typeof(ContextFactory).GetField("appConfig", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
System.Reflection.FieldInfo agentServiceBindingInfo = typeof(AppConfig).GetField("m_agentServiceBinding", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
System.Reflection.FieldInfo contextRegistryServiceBindingInfo = typeof(AppConfig).GetField("m_contextRegistryServiceBinding", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
System.Reflection.FieldInfo defaultServiceBindingInfo = typeof(AppConfig).GetField("m_defaultServiceBinding", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
BasicHttpBinding binding = new BasicHttpBinding();
binding.MaxReceivedMessageSize = 0x7fffffffL;
binding.MaxBufferSize = 0x7fffffffL;
agentServiceBindingInfo.SetValue(appConfigInfo.GetValue(contextFactory), binding);
contextRegistryServiceBindingInfo.SetValue(appConfigInfo.GetValue(contextFactory), binding);
defaultServiceBindingInfo.SetValue(appConfigInfo.GetValue(contextFactory), binding);

Of course, in a production app, I’d ensure that there is a log (auditable event) of such programmatic override activity. I might also consider presenting the user with a suggestion, requesting that the software be given the opportunity to auto-correct the value (e.g. updating the effective application configuration file).

Both Pie and Marko have blogged about content-enabled applications, or what Gartner calls CEVAs (content-enabled vertical applications).

As it so happens, I’ll be presenting there will be a session on this subject next month at EMC World 2009.

Based on my research of what folks label a content-enabled application, two things rise to the top: process (surrounding content) and subject matter expertise (individual or group surrounding process), and context. OK, three things.

For example, Forrester defines content-centric applications as “solutions that put the business’ content to use, and add context along the way–to support line-of-business needs.” Example solutions include customer self-service, claims processing, proposal management, contract management, and case management.

Other CEVA vendors argue that content-enabled applications are process-oriented, not content-centric. I tend to prefer this viewpoint. A claim is valueless in itself. Only once is claim is processed is value realized, including taking a future liability off the books.

Content-enabled applications should facilitate the convergence of content, collaboration, interaction, and process.

Before you leverage your content in an application to generate value, ask yourself few questions:

• Who uses the content? Why? How?
• What processes does the content support?
• If I’m not a subject matter expert for this type of content, who can I involve to design a better application experience?
• What processes does it support?
• What context is involved, either centrally or peripherally?

Start with something familiar to just about anyone these days: email (or IM, micro-blogging, etc.). Answer the questions. See how applications, for example, around email have evolved. Think about where current email applications may have untapped potential. Etc.

So, where have all the CEVAs gone (as Marko asks)?

• I think that we in the content management business do ourselves a disservice by overly complicating concepts (e.g. behind TLAs or FLAs). Although fine as a conceptual catalyst, CEVA is self-defeating, IMHO, as a rallying label.
• I agree that CMIS has great potential to increase the availability of content-enabled applications, if for no other reason, because application development that consumes the proposed standard should have a greater return on investment by being applicable to multiple content repositories. (ECM vendor partners are you listening?)
• In the end, it’s the application, not the content or the process or the people. That is, if you’re just adding a document and perhaps a workflow to some code, you may have an app…but it won’t be used. Focus on user experience (i.e. the meaningful, intuitive presentation of content, context and process together).

Back to EMC World…          

I’ll miss interacting with ‘Zilla at the conference. It was at EMC World in 2007 (also held in Orlando, FL) that I first met Mark in person.

If you are able to make the conference and consider yourself to be a “2.0 type,” you may be interested in Len’s advert. Looks like there is even a LinkedIn event established for the conference.

I plan to tweet the conference and otherwise engage with the community. In the meantime, if you plan to attend my session (as presented by others), please feel free to comment (here or ECN) on your thoughts about content-enabled applications and what you’d like discussed or demoed. Thanks in advance.

My colleague and technical writer, Joe Ferrie, just uploaded the second edition of the DFS 6.5 Development Guide to the EMC Developer Network (EDN) here. The information here is applicable to DFS 6.5 and DFS 6.5 SP1.

(I’m still working on this, but at least this content is available via EDN.)

Some highlights of this edition are as follows:

• A new content transfer chapter, with practical information about uploading and downloading content using Base64 and MTOM, as well as using UrlContent to get content from Accelerated Content Services (ACS). Examples are provided for WSDL-based consumers, as well as productivity layer consumers. Unified Client Facilities (UCF) now gets its own chapter.
• Details of Java productivity layer dependencies so that you can more easily understand what JAR files you need on your ClassPath given for your particular development scenario
• A new chapter comparing DFC and DFS, which is expected to be useful for DFC developers who are ramping up with DFS and want to compare the general approach and specific operations
• A revised explanation of the sometimes confusing restrictions on retrieving deep relationships in DataObjects.

Thanks, Joe!

Continuing my collaboration with John Sweeney (or his collaboration with me), today we’ll examine the DFS Schema service and do so in .NET as a direct-to-WSDL consumer. This tutorial builds upon a previous tutorial; so, if you’re not already familiar with it, please read this post and play with this sample. You’ll also need and be familiar with using Documentum Administrator (DA) and Documentum Composer 6.5 SP1.

Thanks to John for doing the legwork in this tutorial and for allowing me to share it all with you here. (Although, I’d really like to see John blog about this directly; he has a lot to share.)

Not only can the DFS Schema service return value-assist values, it also supports dynamic value assistance, including the handling of dependencies (e.g. one attribute value-assist dynamically built based on the value of another attribute).

This tutorial demonstrates how to use the DFS Schema service to perform dynamic value-assist tasks. Knowledge of Documentum Administrator, Documentum Composer 6.5 SP1, DFS 6.5 SP1, Visual Studio 2008 and WSDL-based consumption of DFS with .NET is assumed.

Before we begin, we’ll need to create users, groups and an object type to use as test data.

Step 1 – Create users and groups (to be performed with Documentum Administrator)

1. Create three groups named writers, reviewers and publishers in your repository.

2. Create six users. Name them appropriately, but for this tutorial, they will be referred to as User1–6. Put the users in the new groups, as specified in the following chart:

Group	Members
writers	User1, User2
reviewers	User3, User4
publishers	User5, User6

Step 2 – Create a new object type (to be performed with Documentum Composer 6.5 SP1)

1. Open Documentum Composer and create a new project.

2. Add a new type called kb_document with a supertype of dm_document.

3. Add a new attribute to the type named document_state (as shown in the following image).

4. Expand the document_state attribute and select Value mapping.

5. In the Conditional Assistance section, click New…

6. Add Draft,Review,Publish as values of Fixed List (as shown in the following image) and click OK.

Your Conditional Assistance section should now look like this:

7. Add another new attribute to the type named assigned_to as shown in the following image.

8. Expand the assigned_to attribute and select Value mapping.

9. In the Conditional Assistance section, click New…

10. Add the following query:

select users_names from dm_group where group_name = 'writers'

Set the other fields (as shown in the following image).

The value-assist list will be populated with users who are members of the writers group by default, when document_state does not have a value of Review or Publish.

11. In the Conditional Assistance section, click New…

12. Add the following query:

select users_names from dm_group where group_name = 'reviewers'

Set the other fields (as shown in the following image).

The value in the Expression field will cause the value-assist list to be populated with users who are members of the reviewers group, but only when document_state has a value of "Review."

13. In the Conditional Assistance section, click New…

14. Add the following query:

select users_names from dm_group where group_name = 'publishers'

Set the other fields (as shown in the following image).

The value in the Expression field will cause the value-assist list to be populated with users who are members of the publishers group, but only when document_state has a value of "Publish."

Your Conditional Assistance section should now look like the following:

15. Install the Documentum project to your repository.

Step 3 – Retrieve the value-assist list (using C# and the .NET Framework 3.0 or higher)

Note: the ServiceContextHeader class used in this tutorial comes from this prior sample, as noted above.

The following code snippet will return group members in the ValueAssist Values list. A PropertySet is created for document_state. The value of document_state will alter the dynamic-assist values for the assigned_to property.

// Get a reference to the DFS Schema service
SchemaServicePortClient schemaService =
    new SchemaServicePortClient("SchemaServicePort"); 

StringProperty sp = new StringProperty();
sp.name = "document_state";
// assigned_to will have different dynamic-assist values, 
// depending upon the value set here
sp.Value = "Publish"; // or Review or Draft

// Create a PropertySet for document_state, which assigned_to depends upon
PropertySet ps = new PropertySet();
ps.Properties = new Property[1];
ps.Properties[0] = sp; 

using (OperationContextScope scope =
           new OperationContextScope(schemaService.InnerChannel))
{
    // Add the ServiceContextHeader info to the outgoing request
    OperationContext.Current.OutgoingMessageHeaders.Add(
        new ServiceContextHeader(repositoryName, userName, password)); 

    // Get the values for the assigned_to property
    ValueAssist valueAssist = schemaService.getDynamicAssistValues(
        repositoryName, "DEFAULT", "kb_document", "assigned_to", ps, null); 

    // Display the values
    if (valueAssist != null || valueAssist.Values != null)
    {
        foreach (string s in valueAssist.Values)
            MessageBox.Show(s, "Value Assist Value");
    }
}

The following table shows the expected results:

document_state value	assigned_to values
Draft	User1, User2
Review	User3, User4
Publish	User5, User6

It is worth noting that if you execute SchemaService.getTypeInfo for kb_document, and examine the assigned_to property, you can determine that the property has dependencies. The returned TypeInfo.PropertyInfos[n].Dependencies will contain an entry for document_state. You can check this beforehand as a way of determining if setting one property (document_state) should trigger a refresh of the value list (calling getDynamicAssistValues again). This is very useful for a picklist property page where the values of one list depend on the value of another.

Here endeth the lesson…

Update 2/6/2009: In order for you to spend more time understanding dynamic value assistance with DFS, I’ve uploaded a Visual Studio project to EDN here. Enjoy.

As indicated previously, I’ve uploaded a CMIS v0.5 sample to EDN. This sample works with EMC Documentum CMIS EA2.

This CMIS sample is intentionally similar to a sample produced previously for DFS 6.5 SP1. The intent is to help you compare and contrast one set of service contracts from the other. In doing so, please keep in mind that CMIS is focused on basic library services for content management—common features across supporting repositories—while DFS is focused on the broader richness of the EMC Documentum ECM Platform.

It’s worth noting that in the case of its CMIS Repository service interaction, this sample EXE was also used by IBM during this week’s TC meeting against their P8-based WSDL endpoint—requiring only a binding configuration change (i.e. zero code changes).

I mentioned that the CMIS AtomPub service (introspection) document for EA2 is accessible as follows: <code>http://host:port/resources/cmis</code>. Let’s say your EA2 installation is running at localhost on 8080, then a request for this document will return the following type of response:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<ns3:service xmlns="http://www.w3.org/2005/Atom" xmlns:ns2="http://www.cmis.org/2008/05" xmlns:ns3="http://www.w3.org/2007/app">
  <ns3:workspace ns2:id="dfs">
    <title type="text">dfs</title>
    <ns2:repositoryInfo>
      <ns2:repositoryId>dfs</ns2:repositoryId>
      <ns2:repositoryName>dfs</ns2:repositoryName>
      <ns2:repositoryDescription>dfs</ns2:repositoryDescription>
      <ns2:vendorName>EMC</ns2:vendorName>
      <ns2:productName>Documentum</ns2:productName>
      <ns2:productVersion>6.5.0.033</ns2:productVersion>
      <ns2:rootFolderId>0c00302180000105</ns2:rootFolderId>
      <ns2:capabilities>
        <ns2:capabilityMultifiling>true</ns2:capabilityMultifiling>
        <ns2:capabilityUnfiling>false</ns2:capabilityUnfiling>
        <ns2:capabilityVersionSpecificFiling>true</ns2:capabilityVersionSpecificFiling>
        <ns2:capabilityPWCUpdateable>false</ns2:capabilityPWCUpdateable>
        <ns2:capabilityPWCSearchable>false</ns2:capabilityPWCSearchable>
        <ns2:capabilityAllVersionsSearchable>true</ns2:capabilityAllVersionsSearchable>
        <ns2:capabilityQuery>both</ns2:capabilityQuery>
        <ns2:capabilityJoin>inneronly</ns2:capabilityJoin>
        <ns2:capabilityFullText>fulltextandstructured</ns2:capabilityFullText>
      </ns2:capabilities>
      <ns2:cmisVersionsSupported>0.5</ns2:cmisVersionsSupported>
    </ns2:repositoryInfo>
    <ns3:collection href="http://localhost:8080/resources/cmis/repositories/dfs/objects/0c00302180000105/children" ns2:collectionType="root-children">
      <title type="text">root-children</title>
    </ns3:collection>
    <ns3:collection href="http://localhost:8080/resources/cmis/repositories/dfs/objects/0c00302180000105/descendants" ns2:collectionType="root-descendants">
      <title type="text">root-descendants</title>
    </ns3:collection>
    <ns3:collection href="http://localhost:8080/resources/cmis/repositories/dfs/types" ns2:collectionType="types-children">
      <title type="text">types-children</title>
    </ns3:collection>
    <ns3:collection href="http://localhost:8080/resources/cmis/repositories/dfs/types" ns2:collectionType="types-descendants">
      <title type="text">types-descendants</title>
    </ns3:collection>
    <ns3:collection href="http://localhost:8080/resources/cmis/repositories/dfs/checkedout" ns2:collectionType="checkedout">
      <title type="text">checkedout</title>
    </ns3:collection>
    <ns3:collection href="http://localhost:8080/resources/cmis/repositories/dfs/queries" ns2:collectionType="query">
      <title type="text">query</title>
    </ns3:collection>
  </ns3:workspace>
</ns3:service>

Your repository name and object identifiers will likely differ from the example references above, but hopefully you get the gist of the response payload.

Comparing the RESTful AtomPub binding to the SOAP binding in CMIS, one has to make two service requests to yield the same repository information (i.e. the block of data represented by <code>repositoryInfo</code> above) as follows:

repositories = repositoryService.getRepositories();
foreach (cmisRepositoryEntryType repository in repositories)
{
  cmisAnyXml repositorySpecificInformation;
  string repositoryId = repository.repositoryID,
         repositoryRelationship,
         repositoryDescription,
         vendorName,
         productName,
         productVersion,
         rootFolderId,
         cmisVersionsSupported;
  cmisRepositoryCapabilitiesType capabilities;
  XmlAttribute[] AnyAttr;
  XmlElement[] Any;
  repositoryService.getRepositoryInfo(ref repositoryId, out repositoryRelationship,
         out repositoryDescription, out vendorName, out productName,
         out productVersion, out rootFolderId, out capabilities,
         out cmisVersionsSupported, out repositorySpecificInformation,
         out Any, out AnyAttr);
  . . .
}

Comparing CMIS Repository service WSDL consumption with DFS Search service WSDL consumption, the same DFS-based consumer code is as follows:

Repository[] repositories = searchService.getRepositoryList(null);
foreach (Repository repository in repositories)
{
  . . .
}

To be clear, these examples are not provided for me to argue that one approach is better than another but rather to show how approaches differ based on domain model, use cases, etc.

I’ll leave it as an exercise for the reader to perform similar comparisons where query support and object support is concerned between DFS and CMIS.

Perhaps it’s also useful to comment on how WS-Security header information is passed to CMIS WSDL endpoints, since CMIS WSDL doesn’t currently declare headers explicitly in the service contract.

This sample injects WS-Security headers via app.config-based declaration (versus programmatically):

<extensions>
  <behaviorExtensions>
    <add name="usernameToken" type="SecurityMessageInspector.UsernameTokenBehaviorExtensionElement, SecurityMessageInspector, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>
  </behaviorExtensions>
</extensions>
<behaviors>
  <endpointBehaviors>
    <behavior name="UsernameTokenBehavior">
      <usernameToken username="Administrator" password="emc" passwordType="PasswordText"/>
    </behavior>
  </endpointBehaviors>
</behaviors>

Right away, understand that this is a sample—you will likely want to take a more secure approach to managing user credentials. Certainly, if you employed this approach, you should employ a secure transport (i.e. SSL). Please see the sample solution’s README file for more details if a more programmatic approach is desired (with or without SSL).

There are other ways to "wire" WS-Security header creation and passing into applications. This particular sample takes a more subtle (less in-your-face) approach to accomplish this concern. Regardless, implicit SOAP headers in a contract require extra coding on the part of a consumer.

Earlier today I posted to EDN a new sample project that demonstrates consuming DFS web services directly from their WSDL in a Visual Studio 2008 environment. Right up front, I want to credit my colleague John Sweeney, who really should start blogging, with providing the original work contained in this sample. My subsequent contribution was mostly UI/UX-related. Thanks, John!

After downloading and extracting the sample to your local development machine, open the solution in Visual Studio 2008. The default code assumes that you’re running the DFS web services locally (i.e. IP 127.0.0.1 and port 8080). You should, of course, modify the IP address and port to match your particular development environment.

The main intent of this sample is to demonstrate various ways to authenticate via DFS. It’s worth noting that this sample doesn’t cover single sign-on (SSO) support in DFS, nor does it cover WS-Security header-based authentication. Good demos to be certain…

As the user interface (UI) above tries to clearly state upfront, content repository (aka Docbase) name cannot be null or empty, regardless of authentication approach. Given authentication via ServiceContext header, user name and password cannot be null or empty. Given authentication via ContextRegistry runtime service, when token is null or empty, user name and password cannot be null or empty, and when user name and password are both null or empty, token cannot be null or empty.

One thing that is still a bit obscure in the current UI is that authentication via DFS can be a two-step or one-step process, depending on the situation. If you choose "Via ContextRegistry…" and a Context Registry token isn’t provided to DFS, two runtime service invocations will be made. In all other cases, there is one service invocation.

Assuming that your connection details are valid given your authentication approach, this sample will (a) retrieve a repository list, (b) retrieve cabinets, and (c) retrieve content (i.e. transfer MenuItemTemplate.ini to your desktop).

A previous direct-to-WSDL DFS consumer sample I posted, targeted .NET 3.0 and WCF "v1." This sample targets .NET 3.5 and WCF "v2" instead, along with support for Silverlight 2. It accomplishes this change via LINQ to XML (e.g. leverages System.Xml.Linq.XDocument instead of System.Xml.XmlDocument).

If you need to target this sample at .NET 3.0, in addition to adjusting the project build properties, removing the project reference to the System.Xml.Linq.dll assembly, and removing the System.Xml.Linq namespace declaration in ServiceContextHeader.cs, you’ll need to change the relevant code within OnWriteHeaderContents. For example:

  XDocument doc = null;
  using (StringWriter sw = new StringWriter(CultureInfo.CurrentCulture))
  {
      XmlSerializer xs = new XmlSerializer(typeof(ServiceContext));
      xs.Serialize(sw, serviceContext);
      doc = XDocument.Load(new StringReader(sw.ToString()));
  }

would become:

  XmlDocument doc = null;
  using (StringWriter sw = new StringWriter(CultureInfo.CurrentCulture))
  {
      XmlSerializer xs = new XmlSerializer(typeof(ServiceContext));
      xs.Serialize(sw, serviceContext);
      doc = XmlDocument.LoadXml(new StringReader(sw.ToString()));
  }

etc.

Although, it’s not currently employed in the sample, there is also code to add a ContentTransferProfile to the ServiceContext header.

As always, consult the DFS Developer Guide for complete details on everything that may be passed in the ServiceContext header.

I do expect that this sample will be incorporated into the DFS SDK and DFS technical publications content; however, I wanted to get this into your hands sooner rather than later. Cheers…

While I’ve been saying “see em eye ess” for CMIS up to this point, I’ve discovered that others are pronouncing CMIS “see miss” instead.

• One’s pronunciation of SQL has been offered in support of pronouncing CMIS (i.e. “see qul” versus “ess queue el”). (I say “see qul;” so perhaps I should be saying “see miss.”)
• Using the shortest pronunciation possible as measured by number of syllables has been offered in support of “see miss” (i.e. two versus four syllables).
• Conjunctives like CMIS-enabled, CMIS-ready, etc. has been offered in consideration of “see miss.” On other hand, “see em eye ess” may be better in conversation with someone not yet familiar with the standards effort.
• One’s locale and native language has also been offered in support of “see em eye ess” (e.g. easier to understand in conversation with non-native speakers by avoiding use of two common English words, which can be hard to parse in the middle of a sentence for someone not already used to the meaning).
• Pop culture features shows like CSI, SVU and NCIS. Initialism applies to these shows (e.g. you don’t hear “see sci” or “en sis”). Therefore, …

So, how do you say CMIS?

P.S. Yes, this is completely unimportant in every technical aspect where the standards effort around CMIS is concerned. Nevertheless, consistent identity, including pronunciation matters, and the standards effort is just getting started…

P.P.S. Happy Thanksgiving!

Today my EMC colleagues Dr. David Choy and Patricia Anderson presented CMIS to SOA World attendees, “An Industry Effort to Define a Service-Based Interoperability Standard for Content Management.” They were kind enough to let me post their work here.

Today, EMC announced new releases of EMC Captiva products (i.e. EMC Captiva InputAccel 6.0 and EMC Captiva Dispatcher 6.0). I want to address the benefits of service-oriented infrastructure related to capture as embodied by these new releases.

The big deal with SOA and InputAccel 6.0 (IA6) is the connectivity it enables with other enterprise applications.

Capture depends heavily on validation of the captured data so access to systems that can supply information based on an extracted value or can perform the validation of extracted values is necessary. Service-orientation in IA6 lets capture be part of a company’s composite TCM applications.

Prior to the release of IA6, capture systems “connectivity” was restricted to ODBC, dropping files on file shares, and/or duplicating validation rules in software.

Another potentially big deal is the exposure of Captiva’s capture functionality to other applications (e.g. a web service for importing data into Captiva).

Today Captiva takes (captures) data from scanners, email, fax machines and legacy systems using specialty importers and file shares. Using web services will reduce complexity by allowing for a single method to be used to take in data from all kinds of systems.

Capture processing tends to occur in large batches; so, the “queue” behavior of a file share is useful. However, it lacks a handshake when the data has been picked up.

A web service would be more likely to be used by an interactive process or could be used as a call-back with the file share method to give a handshake.

It will be interesting to see how service-orientation within capture takes hold.

I want to thank my colleague, Clay Mayers, Captiva CTO, for contributing to this post. (Ah, another potential CMA blogger target… )

During the first keynote of PDC last week, Bob Muglia associated this year’s PDC with the 1992 PDC, which featured the coming out of Windows NT. (I still think of “WNT” as “V++ M++ S++”, given David Cutler‘s leadership on both operating systems.)

I think there is much to draw from this comparison where the future for Windows Azure is concerned.

In 1992, PDC’s coverage of NT followed after at least a two-year effort to develop the new operating system (e.g. the OS first ran–minimally and non-commercially at Microsoft–in 1990). Commercial availability followed PDC a year later (i.e. Windows NT 3.1). However, adoption of NT didn’t take off until 1996, with the release of Windows NT 4.0 (and the availability of hardware and applications necessary to accomplish day-to-day work).

I’m not saying that Azure’s “take-off” won’t be until 2012 (i.e. “Red Dog”‘s 2006 commencement plus six years). Yet, Microsoft’s own comparison of Azure to NT is helpful in combating both near-term tendency to hype and in understanding the long-term potential of the cloud where Microsoft envisions it to be.

Robin Cover just published a technology report for CMIS to support the activities of the OASIS CMIS TC and external commentary, and with the intent to update the document with relevant bibliographic references as the Technical Committee work progresses. Thanks, Robin.

Certainly the vision of Windows Azure (aka “Red Dog”) and the Azure Services Platform is substantial. However, in order for Microsoft, its partners and customers to realize it, it must deliver business value.

Internal or external, cloud computing has to address a set of real business problems in order to become a relevant part of one’s development arsenal. Some business models are more closely aligned with the cloud than others. New business models will emerge.

I guess that the technology industry is tired of TLAs like MSP and ASP. In fact, it seems like FLAs like SaaS and PaaS are passé, too. Only five characters will do, and analogy has replaced acronym: cloud.

During the keynotes this morning, Ray Ozzie suggested that cloud (or utility) computing is materially different than past innovations upon which it rests since it is focused on the externalization of IT and the critical requirement to scale-out.

According to Gartner, there are five trends driving companies like Microsoft and Google in their march toward cloud computing as follows:

• Software as a service
• Open-source technologies
• Web 2.0 products, such as collaborative technologies, social networking and wikis
• Consumerization of technology
• Global class, a new way to deliver computing services

So I’m looking for content and discussion concerning cloud computing the addresses the following questions:

• What are the API differences between this OS (Windows Azure) and a traditional Windows OS (e.g. Windows Server 2008)? What features/functions are unique to Azure (and why)?
• What about composition in the cloud?
• What about cross-app-in-the-cloud functionality (e.g. events and other synergies)?
• What are the significant ISV/partner opportunities (e.g. platform level, application level and integrated solutions level) created by the “Azure ecosystem”?
• What new issues arise in the cloud? Regulatory compliance cannot be compromised. Comingling of both live and backed-up data can pose concerns. “Premise matters” (eventually); so virtualization, geography, sovereignty, etc. can pose additional concerns. Etc. How does Azure address such concerns?

In a few minutes, I’ll be taking an initial “lap around” Azure, which should be interesting. Stay tuned…

It appears that a majority of what I plan to attend at this year’s Microsoft Professional Developers Conference (PDC) is focused on cloud computing. Today, for example, I plan to attend the following sessions:

1. Keynote – Ray Ozzie, Amitabh Srivastava, Bob Muglia and David Thompson
2. A Lap around Windows Azure
3. “Dublin” and .NET Services: Extending On-Premises Applications to the Cloud
4. The Future of C# – Anders Hejlsberg
5. A Lap around the Azure Services Platform – John Shewchuk
6. Developing and Deploying Your First Windows Azure Service

Well, I’m off to grab a seat for the keynote session. I’ll follow up with a post on what I expect to learn about cloud computing, next.

Update 10/28/2008: FWIW, here is the rest of my plans at PDC (besides networking, of course):

Day 2

1. Keynote – Ray Ozzie et al
2. Keynote – Don Box & Chris Anderson
3. Live Services: What I Learned Building My First Mesh Application
4. A Lap around “Oslo”
5. Architecture of the .NET Services
6. Windows Azure: Architecting & Managing Cloud Services

Day 3

1. Keynote – Rick Rashid
2. .NET Services: Connectivity, Messaging, Events, and Discovery with the Service Bus…or Panel: The Future of Programming Languages…or Parallel Programming for Managed Developers with the Next Version of Microsoft Visual Studio
3. Windows 7: Design Principles for Windows 7
4. .NET Services: Logging, Diagnosing, and Troubleshooting Applications Running Live in the Cloud or Improving .NET Application Performance and Scalability
5. Windows Azure: Cloud Service Development Best Practices
6. .NET Services: Access Control Service Drilldown

Day 4

1. Microsoft .NET Framework: Declarative Programming Using XAML
2. .NET Services: Messaging Services – Protocols, Protection, and How We Scale
3. “Oslo”: Building Textual DSLs or Designing Your Application to Scale or Windows Azure: Programming in the Cloud
4. An Introduction to Microsoft F# or .NET Services: Orchestrating Services and Business Processes Using Cloud-Based Workflow
5. …or, instead of the regular session rhythm, there are 3-part symposia (e.g. on services [1], [2] and [3]…difficult choice…

This week has seen REST experts Roy Fielding and Sam Ruby comment on CMIS. As someone directly involved in CMIS, I wanted to acknowledge both Roy’s remarks and Sam’s remarks, which follow onto Roy’s.

The standards effort based in OASIS that is CMIS is indeed just getting started, as Sam notes. There is a lot of work to be done, and CMIS needs timely, constructive feedback from the wider community if it is to become widely adopted.

I apologize for the short notice, but I will be presenting a webinar on Content Management Interoperability Services (CMIS) this Thursday. Registration is still open: http://www.emc.com/events/2008/q3/09-18-08-cmis-launch.htm. I hope that you can not only listen to the presentation but also participate actively in the Q&A portion.

If you cannot participate but are still interested in CMIS, I will do my best to capture the Q&A in a follow-up post. Also, I believe that all those who register will receive an email with information on accessing a recording of the live event.

My colleague, Dave Choy, will be joining me to assist with Q&A; so, please come prepared with your questions. If the blogosphere since last Wednesday (i.e. CMIS launched on 9/10) is any indication, that shouldn’t be too much to ask. 

Update (9/18/2008): Thanks to those who attended this webinar and especially to those who asked questions. The audio recording of this event is already available here, and it does capture the Q&A toward the end.

Update (9/19/2008): You can also replay the webcast and download a PDF rendition of the slides here.

I am excited to (finally) say that EMC, IBM and Microsoft have announced the creation of a jointly developed interface specification called Content Management Interoperability Services, or CMIS. This is important news for the industry as CMIS uses web services to provide greater interoperability across multiple Enterprise Content Management (ECM) repositories.

The current draft specification will be submitted to OASIS and managed by technical committee to guide it toward finalization as a standard.

I said “finally” above because it’s been over two years since I first talked about ECM standards, admittedly (and out of legal obligation) at a high-level–followed up one year ago, here. So, finally, all can become clear…!

In preparation for today’s announcement, I had the opportunity to interview Kyle McNabb, Principal Analyst and Research Director at Forrester Research, to share his thoughts on the announcement. You can listen to Kyle’s perspectives as I ask him the following questions:

• Why is CMIS needed?
• Why does it matter who is involved in CMIS?
• Why is CMIS a step in the right direction?
• What will be the near-term impact of CMIS on the market?
• What will be the impact of CMIS to the industry as whole, including ISVs as well as organizations at the enterprise or department levels?
• What can enterprises expect in the future and how CMIS will help them over the long haul?

One of the impacts Kyle sees as a result of CMIS particularly resonates with me: separation of content repositories from content-centric applications in a manner similar to how SQL standardization enabled separation of the relational database from data-centric applications. Entirely new classes of applications (e.g. ERP) emerged with the arrival of SQL, and I’m optimistic about the same kind of potential emergence with the announcement of CMIS.

Frankly, I agree with Kyle’s pragmatic assessment of expectation and timeline. I also believe it will take time before we see new classes of content-centric applications emerge, but CMIS is, in my opinion, a step in the right direction.

As with any significant industry announcement, I expect to see plenty of press coverage by those companies involved, by analysts, etc. I’m also looking forward to what my EMC colleagues have to say about CMIS (e.g. Cornelia Davis, Andrew Chapman, Dave Graham, Len Devanna, Chuck Hollis, and Mark Lewis).

I encourage you to learn more about CMIS on the EMC Developer Network. For example, you can download the complete set of WSDL/XSD documents for the SOAP binding as well as schemas and example XML documents for the REST binding. You can also download a whitepaper that details technology concepts and business considerations involved with CMIS.

This first post on CMIS is intended to set the stage for deeper conversations about the specification, its domain model, its service model, and what its impact can become. So, if you have questions, please don’t hesitate to leave a comment here or otherwise join the conversation.

Update (today):
(1) Chuck Hollis has posted his thoughts on why CMIS is not JAS (just another standard). Good reading.
(2) Andrew Chapman has posted his thoughts (er, introduced a new word) on potential SharePoint de-silofication driven by CMIS. Another good read.

Update (9/12/2008):
(1) OASIS Proposed Charter for CMIS TC
(2) Mark Lewis addresses commoditization questions raised by CMIS.

Update (9/14/2008): OASIS coverage of CMIS news

My friend and colleague Paul Warren recently posted content that talks about the creation of Enterprise Content Services (like those in DFS) in the context of an integrated development environment (IDE):

• Creating DFS services using Documentum Composer
• Creating DFS services using the Eclipse IDE for Java EE Developers

WTP support is something the Composer team is hard at work on, and this will change the nature of DFS tooling, too.

Essentially we’re working together to promote more standard developer workflow and development lifecycle by embracing tools developers already use to build services. While WTP assumes Eclipse and Composer is indeed powered by Eclipse, that doesn’t mean that Eclipse is the only IDE for Enterprise Content Service development. We’re working on changing the nature of the DFS SDK, too, to better emphasize, for example, how to use Visual Studio and Windows Communication Foundation directly to build service consumers.

What tools, including IDEs, do you use to build Enterprise Content Services and ECS-based solutions?

You may have seen this week’s press release (PR) concerning the launch of the EMC Documentum 6.5 platform. Given that this blog is referenced in the PR’s sidebar, I thought it would be appropriate for me to offer my perspective on this release.

When the Documentum Foundation Services (DFS) team first embarked on its mission to better service-orient the Documentum platform, I suggested that, over time, the very focus of our daily work–services and common service infrastructure–would become less “talked about.” I suggested that services alone deliver less value than services in the context of processes and processes in the context of solutions.

So, ultimately EMC has to deliver relevant, robust solutions to market much more than just web services. This is exactly the focus of the EMC PR–and each solution discussed is built using Enterprise Content Services (ECS).

Take CenterStage (aka “Magellan”), Media WorkSpace, and My Documentum as D6.5 solution examples. One user experience differs fairly significantly from another user experience (e.g. CenterStage Essentials versus Media WorkSpace). Looking under the covers, one implementation (i.e. presentation layer and application behavior) also differs from another implementation. However, common business logic is provided to each solution via a consistent set of services (e.g. Object, Query, Schema, Access Control, etc.).

Each solution is worth its own coverage, but I will allow solution teams to accomplish this (e.g. content like this).

Instead, I’d like to focus on the progress achieved in the D6.5 release where services and common service infrastructure are concerned:

1. The number of out-the-box Enterprise Content Services (ECS) in DFS has more than doubled in 6.5, from the six to 13. The total number of ECS across D6.5 has grown nearly fourfold, from six to 23.

• Six original services with DFS 6.0: Object (enhanced in 6SP1 to support external objects; enhanced again in 6.5 to support aspects), Query, Schema, Search (enhanced functionality in 6.5 for clusters), Version Control (enhanced in 6.5 to support aspects), Workflow
• Seven new services with DFS 6.5: Access Control, Analytics, Comment, Lifecycle, Query Store, Task Management (WS-HumanTask), Virtual Document
• Plus 10 additional, new services beyond (i.e. not packaged with) DFS 6.5:
  Content Delivery, Electronic Signature, ERP Integration (SAP), Federated Proxy, Formal Record, Physical Records Library, (Records Management) Policy, (Content Transformation) Profile, Retention Markup, (Content) Transformation

Bottom line #1: there are many more services with D6.5 from which to compose content-centric applications.

2. Common service infrastructure has been significantly enhanced at the same time. For example:

• Contract first (or WSDL first) development of services is supported in addition to code first development.
• Design time discovery of services is supported via a new service catalog or an existing UDDI v2 compliant service registry. Classification of service occurs via the concept of catalogs and categories, by default.
• Modularity has increased at the binary (e.g. JAR file) level to promote better composition (i.e. only take what you need).
• Single sign-on (SSO) support has been improved.

Bottom line #2: you have more options now to provide, discover and consume services.

Certainly there is a lot more to each bullet point above, and I plan to drill down into several points in future posts.

…and I didn’t even use the term “Web 2.0″…until now.

In our previous conversation, we left with a missing header to resolve. This post will resolve this issue and wrap-up the sample DFS Object service consumer based on direct proxy via Visual Studio/WCF.

First, we need to introduce a new internal class, ServiceContextHeader, as follows:

internal class ServiceContextHeader : MessageHeader
{
    private string repositoryName = null;
    private string userName = null;
    private string password = null;

    public ServiceContextHeader(string repositoryName, string userName, string password)
    {
        this.repositoryName = repositoryName;
        this.userName = userName;
        this.password = password;
    }

    protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
    {
        // Please note that there can be more to a ServiceContext instance than
        // what this intentionally simple example specifies. This message header
        // implementation doesn't cover all aspects of ServiceContext.

        // In order to proxy ServiceContext, you must first establish a service
        // reference to the DFS runtime Context Registry service.
        ServiceContext serviceContext = new ServiceContext();
        RepositoryIdentity repositoryIdentity = new RepositoryIdentity();
        repositoryIdentity.repositoryName = repositoryName;
        repositoryIdentity.userName = userName;
        repositoryIdentity.password = password;
        serviceContext.Identities = new Identity[1];
        serviceContext.Identities[0] = repositoryIdentity;

        // We haven't communicated with the DFS runtime Context Registry service;
        // so we don't have a token to "write," nor are we specifiying locale in 
        // our ServiceContext instance.

        StringWriter sw = new StringWriter();
        XmlSerializer xs = new XmlSerializer(typeof(ServiceContext));
        xs.Serialize(sw, serviceContext);
        String xml = sw.ToString();
        sw.Close();

        XmlDocument document = new XmlDocument();
        document.LoadXml(xml);

        foreach (XmlNode node in document.LastChild.ChildNodes)
        {
            XmlElement element = (XmlElement)node;
            XmlReader reader = new XmlNodeReader(element);
            writer.WriteNode(reader, true);
        }
    }

    public override string Name
    {
        get { return "ServiceContext"; }
    }

    public override string Namespace
    {
        get { return "http://context.core.datamodel.fs.documentum.emc.com/"; }
    }
}

Next, we need to “inject” this class into our application’s request message processing. So, we need wrap our original call to ObjectService.get() as follows:

DataPackage dataPackage = null;
using (OperationContextScope scope = new OperationContextScope(objectService.InnerChannel))
{
    OperationContext.Current.OutgoingMessageHeaders.Add(new ServiceContextHeader(repositoryName, userName, password));

    dataPackage = objectService.get(objectIdentitySet, operationOptions);
}

In a less contrived context (i.e. your production application), there are other approaches to be considered, and I recommend that you at least read Nick Allen’s post on the subject.

Now, let’s re-run the modified example and examine the SOAP request message:

<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
    <s:Header>
        <ServiceContext xmlns="http://context.core.datamodel.fs.documentum.emc.com/">
            <Identities xsi:type="RepositoryIdentity" userName="_USER_" password="_PWD_" repositoryName="_DOCBASE_" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>
        </ServiceContext>
    </s:Header>
    <s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
        <get xmlns="http://core.services.fs.documentum.emc.com/">
            <forObjects isInternal="false" xmlns="">
                <Identities repositoryName="_DOCBASE_" valueType="OBJECT_ID" xmlns="http://core.datamodel.fs.documentum.emc.com/">
                    <ObjectId id="09003023800037c6"/>
                </Identities>
            </forObjects>
            <options xmlns="">
                <Properties isInternal="false" xmlns="http://core.datamodel.fs.documentum.emc.com/"/>
                <Profiles xsi:type="q1:PropertyProfile" isProcessIncludedUnknown="false" filterMode="SPECIFIED_BY_INCLUDE" xmlns="http://core.datamodel.fs.documentum.emc.com/" xmlns:q1="http://profiles.core.datamodel.fs.documentum.emc.com/">
                    <q1:IncludeProperties>object_name</q1:IncludeProperties>
                </Profiles>
            </options>
        </get>
    </s:Body>
</s:Envelope>

Much better! And, as important, the dialog reveals the same object name as the same example based on the DFS SDK .NET assemblies.

You can download the Visual Studio 2008-based solution for today’s (fully resolved) sample here.

I hope that this series of posts on how the EMC Documentum platform, and especially DFS, supports Microsoft-oriented developers has been helpful.

Cheers…

Update 8/9/2008: There is actually one additional change that is required to properly retrieve the object’s name for presentation on the form. In the previous post, after calling ObjectService.get() and finding the “object_name” property, our form label was set as follows:

    lblObjName.Text = property.ToString();

However, this needs to change in order to avoid prefacing the string value with ToString() content:

    StringProperty s = property as StringProperty;
    lblObjName.Text = s.Value;

This sample has been updated to include this change. Kudos to John Sweeney for the assist.

OK, back to the Olympics…

Rather than leverage the DFS SDK-based .NET assemblies to consume DFS services, some may prefer to leverage Visual Studio’s ability to proxy WSDL/XSD directly and choose instead to involve the Windows Communication Foundation (WCF) designer via Add Service Reference… In this post, I will discuss just such a sample application.

As in the previous example, we’ll build the same Windows Forms application to accomplish the same task (i.e. object name retrieval given object id); however we’ll ignore the .NET productivity layer and proxy the Object service contract directly using Visual Studio and WCF.

After launching Visual Studio, choosing File | New | Project… and creating a new Windows Forms Application project called ObjectServiceConsumer, go to the Solution Explorer, select the project node, right-click and choose Add Service Reference…

Enter the address for the DFS Object service instance to proxy (e.g. the same instance used in the previous example’s browser-based accessibility test). Click Go, and you should see something similar to the dialog captured above. Set the namespace for this reference and choose OK.

Return back to Visual Studio, double-click Form1.cs, after building the same dialog as in the previous example, double-click on the Retrieve button. This will tell Visual Studio to transition from (Windows Forms) designer mode to code editing mode.

Implement your button click handler as follows:

string repositoryName = txtbxRepoName.Text;
string userName = txtbxUserName.Text;
string password = txtbxPwd.Text;
string objId = txtbxObjId.Text; // e.g. a document id of 09123456789abcde

try
{
    ObjectId objectId = new ObjectId();
    objectId.id = objId;
    ObjectIdentity objectIdentity = new ObjectIdentity();
    objectIdentity.Item = objectId;
    objectIdentity.repositoryName = repositoryName;
    ObjectIdentitySet objectIdentitySet = new ObjectIdentitySet();
    objectIdentitySet.Identities = new ObjectIdentity[1];
    objectIdentitySet.Identities[0] = objectIdentity;

    PropertyProfile propertyProfile = new PropertyProfile();
    propertyProfile.filterMode = PropertyFilterMode.SPECIFIED_BY_INCLUDE;
    string[] includeProperties = {"object_name"};
    propertyProfile.IncludeProperties = includeProperties;
    OperationOptions operationOptions = new OperationOptions();
    operationOptions.Profiles = new Profile[1];
    operationOptions.Profiles[0] = propertyProfile;

    DataPackage dataPackage = objectService.get(objectIdentitySet, operationOptions);

    Property[] properties = dataPackage.DataObjects[0].Properties.Properties;
    foreach (Property property in properties)
    {
        if (property.name.Equals("object_name"))
        {
            lblObjName.Text = property.ToString();
        }
    }

    Console.WriteLine("Successfully retrieved object name for object id" + "'" + objId + "': " + lblObjName.Text);
}
catch (Exception ex)
{
    lblObjName.Text = "<error>";
    Console.WriteLine(ex.StackTrace);
    Console.WriteLine("Failed to retrieve object name with exception " + ex.Message);
}
finally
{
    Console.WriteLine("Your cleanup logic goes here.");
}

A few points concerning the above code:

• There is a private field on the Form class, objectService, that is of type ObjectServicePortClient (i.e. from the WCF-generated proxy code) and is set to null initially.
• In the Form class constructor, after the standard Windows Forms InitializeComponent(), objectService is set as follows: new ObjectServicePortClient(“ObjectServicePort”);
• “ObjectServicePort” is a named binding in the WCF-generated proxy code (i.e. declared within app.config).
• As in the previous example, I’m using a pre-release version of DFS 6.5 for this example, but I’m not using anything that isn’t available in DFS 6.0 SP1–this is a very simple example by design.
• You should notice some cosmetic differences between the code above and the code here (e.g. more verbose, fewer conveniences, etc.).

You should now be able to build your application and run it. When you enter a valid object id for the specified repository connection, you should see the object name replace “<tbd>” on the dialog.

But, you don’t. Why?

Well, first of all, if you are running your application server with a console window for output message capture, you likely saw the following message:

. . . com.emc.documentum.fs.rt.SerializableException: Authorization failed, could not find identities in service context with token “temporary/127
.0.0.1-1216079837407–1167916486618885387″
        at com.emc.documentum.fs.services.core.ObjectServiceWebService.get(ObjectServiceWebService.java:268) . . .

Looking at the code above, it’s hopefully clear that the variables userName and password aren’t employed. (If you’re using the JetBrains ReSharper add-in for Visual Studio, the IDE (plugin) actually visually indicates this condition.)

So, let’s do some detective work.

Using a web debugging proxy (e.g. Charles), re-run the above code (i.e. with port forwarding in place). After valid data entry and clicking the Retrieve button, you should see an entry in your web debugging proxy session. Examine the SOAP request message (i.e. “pretty printed” for readability’s sake):

<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
    <s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
        <get xmlns="http://core.services.fs.documentum.emc.com/">
            <forObjects isInternal="false" xmlns="">
                <Identities repositoryName="_DOCBASE_" xmlns="http://core.datamodel.fs.documentum.emc.com/">
                    <ObjectId id="09003023800024ec"/>
                </Identities>
            </forObjects>
            <options xmlns="">
                <Profiles xsi:type="q1:PropertyProfile" isProcessIncludedUnknown="false" xmlns="http://core.datamodel.fs.documentum.emc.com/" xmlns:q1="http://profiles.core.datamodel.fs.documentum.emc.com/">
                    <q1:IncludeProperties>object_name</q1:IncludeProperties>
                </Profiles>
            </options>
        </get>
    </s:Body>
</s:Envelope>

Next, go back to the previous example, and re-run it to capture its SOAP request message. Before you hit Run, though, comment out the following line of code:

context = contextFactory.Register(context);

(We’ll talk more about this in a future post.)

The DFS SDK .NET assemblies-based application issues the following SOAP request message:

<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
    <s:Header>
        <ServiceContext token="temporary/127.0.0.1-1216195928765-692634301" xmlns="http://context.core.datamodel.fs.documentum.emc.com/">
            <Identities xsi:type="RepositoryIdentity" userName="_USER_" password="_PWD_" repositoryName="_DOCBASE_" domain="" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>
            <RuntimeProperties/>
        </ServiceContext>
    </s:Header>
    <s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
        <get xmlns="http://core.services.fs.documentum.emc.com/">
            <forObjects isInternal="false" xmlns="">
                <Identities repositoryName="_DOCBASE_" valueType="OBJECT_ID" xmlns="http://core.datamodel.fs.documentum.emc.com/">
                    <ObjectId id="09003023800037c6"/>
                </Identities>
            </forObjects>
            <options xmlns="">
                <Properties xmlns="http://core.datamodel.fs.documentum.emc.com/"/>
                <Profiles xsi:type="q1:PropertyProfile" filterMode="SPECIFIED_BY_INCLUDE" xmlns="http://core.datamodel.fs.documentum.emc.com/" xmlns:q1="http://profiles.core.datamodel.fs.documentum.emc.com/">
                    <q1:IncludeProperties>object_name</q1:IncludeProperties>
                </Profiles>
            </options>
        </get>
    </s:Body>
</s:Envelope>

Yep, there’s definitely a missing header in today’s sample, as coded above.

It’s also worth noting a few things before continuing:

• The code above requires SSL to avoid cleartext data being sent over the wire. Of course, SSL–and replacing http://… with https://…–only provides transport-level security that is point-to-point in nature (i.e. compared with message-level security that is end-to-end in nature).
• valueType=”OBJECT_ID” – this is missing on the <Identities> element in today’s example but is present in the previous example
• <Properties xmlns=”http://core.datamodel.fs.documentum.emc.com/”/> – this is missing in today’s example but is present in the previous example
• filterMode=”SPECIFIED_BY_INCLUDE” – this is missing on the <Profiles> element in today’s example but is present in the previous example
• isProcessIncludedUnknown=”false” – this is present in today’s example but is missing in the previous example

Before we solve the case of the missing header, let’s resolve the differences just listed:

...
ObjectIdentity objectIdentity = new ObjectIdentity();
objectIdentity.valueType = ObjectIdentityType.OBJECT_ID; //FIX
objectIdentity.valueTypeSpecified = true; //FIX
...
propertyProfile.filterMode = PropertyFilterMode.SPECIFIED_BY_INCLUDE;
propertyProfile.filterModeSpecified = true; //FIX
...
OperationOptions operationOptions = new OperationOptions();
...
operationOptions.Properties = new PropertySet(); //FIX
...

As for the isProcessIncludedUnknown-based difference aforementioned, a quick read of the reference-level documentation for PropertyProfile.setProcessIncludedUnknown() is helpful: “If false, ignore any property in the includeProperties list that is not a property of the repository type. If true, throw an exception if such a property is specified in the includeProperties list. Default value is false.” That is, the WCF-generated proxy makes this default explicity in its SOAP messages; so, although the two XML messages have this difference, they are functionally equivalent.

Next: Leveraging WCF extensibility to add the missing header that the DFS Object service expects…

In a previous post, I introduced web service support in the EMC Documentum platform for the Microsoft-oriented developer. (BTW, sorry for the time lapse since that post to this one–busy getting an important set of products ready for on-time release. ) In this post, I will focus on such support as provided with DFS via the .NET assemblies (aka productivity layer) within the DFS SDK.

Let’s build a simple Windows Forms application using Microsoft Visual Studio 2008. The purpose of this application will be to retrieve the object name from a piece of content in a Documentum repository associated with a particular object id:

After launching Visual Studio, choosing File | New | Project… and creating a new Windows Forms Application project called ObjectServiceConsumer_PL, go to the Solution Explorer, select the References node under the project, right-click and choose Add Reference…

Navigate to your DFS SDK installation and select the set of .NET assemblies that support the DFS Object service. For example, I tend to install the SDK directly under my C: drive; so, I navigated to C:\emc-dfs-sdk-6.5\lib\dotnet:

(Yes, I’m using a pre-release version of DFS 6.5 for this example, but I’m not using anything that isn’t available in DFS 6.0 SP1–this is a very simple example by design.)

The result under the References node should be as follows:

If you’re already developing with .NET 3.5, you may notice that a couple of .NET 3.5 assemblies are missing in the above view. That’s because I decided to target .NET 3.0 for this example since I don’t require anything more from Windows Communication Foundation since its first release (i.e. DFS supports WCF “v1″ in .NET 3.0).

At this point, verify that you will be able to access an instance of the DFS Object service from your application. That is, deploy emc-dfs.ear file via the standalone DFS installer or with the Content Server installer. Launch your browser of choice and retrieve DFS Object service WSDL (e.g. http://localhost:8080/services/core/ObjectService?wsdl). You should see the service contract in your browser.

Return back to Visual Studio, double-click Form1.cs, after building the dialog shown above, double-click on the Retrieve button. This will tell Visual Studio to transition from (Windows Forms) designer mode to code editing mode.

Implement your button click handler as follows:

string repositoryName = txtbxRepoName.Text;
string userName = txtbxUserName.Text;
string password = txtbxPwd.Text;
string objId = txtbxObjId.Text; // e.g. a document id of 09123456789abcde

try
{
    ContextFactory contextFactory = ContextFactory.Instance;
    IServiceContext context = contextFactory.NewContext();
    RepositoryIdentity repoId = new RepositoryIdentity(repositoryName,
                                                       userName,
                                                       password,
                                                       "");
    context.AddIdentity(repoId);

    context = contextFactory.Register(context); // Module and ContextRoot from app.config
    ServiceFactory serviceFactory = ServiceFactory.Instance;

    IObjectService objectService =
        serviceFactory.GetRemoteService<IObjectService>(context); // Module and ContextRoot from app.config

    ObjectId objectId = new ObjectId(objId);
    ObjectIdentity objectIdentity = new ObjectIdentity(objectId, repositoryName);
    ObjectIdentitySet objectIdentitySet = new ObjectIdentitySet(objectIdentity);

    PropertyProfile propertyProfile = new PropertyProfile();
    propertyProfile.FilterMode = PropertyFilterMode.SPECIFIED_BY_INCLUDE;
    propertyProfile.IncludeProperties.Add("object_name");

    OperationOptions operationOptions = new OperationOptions();
    operationOptions.Profiles.Add(propertyProfile);

    DataPackage dataPackage = objectService.Get(objectIdentitySet, operationOptions);

    List<Property> properties = dataPackage.DataObjects[0].Properties.Properties;

    if (properties != null)
    {
        properties.ForEach(delegate(Property property)
                               {
                                   if (property.Name.Equals("object_name"))
                                   {
                                       lblObjName.Text = property.ToString();
                                   }
                               });
    }

    Console.WriteLine("Successfully retrieved object name for object id" + "'" + objId + "': " + lblObjName.Text);
}
catch (Exception ex)
{
    lblObjName.Text = "<error>";
    Console.WriteLine(ex.StackTrace);
    Console.WriteLine("Failed to retrieve object name with exception " + ex.Message);
}
finally
{
    Console.WriteLine("Your cleanup logic goes here.");
}

As noted above in code comments, you should add an Application Configuration File item to your project. After doing so, open the new app.config file in Visual Studio, select its contents and paste (overwrite) them with the contents copied from the sample App.config file in the DFS SDK (i.e. C:\emc-dfs-sdk-6.5\etc\config\App.config). Be sure to modify data relative to your running DFS Object service instance (e.g. ModuleInfo element attributes like port).

You should now be able to build your application and run it. When you enter a valid object id for the specified repository connection, you should see the object name replace “<tbd>” on the dialog.

Obviously this is a trivial sample. However, as I mentioned this is be design, since what I want to do next is contrast this sample with the same goal implemented without DFS SDK .NET assemblies (i.e. using just Visual Studio, its WCF designer and DFS WSDL/XSD content).

You can download the Visual Studio 2008-based solution for today’s sample here.

Next: Using DFS WSDL/XSD (sans DFS SDK .NET assemblies) from Visual Studio…

Shortly after the Documentum 5.2.5 release, customer interest in web services piqued in conjunction with Documentum’s investment in services via service-based business objects. SBOs, as they’re typically referred to, are supported in the Business Object Framework (BOF), which is the codified customization framework for DFC.

So, in order to preserve customer investment in SBOs, the Web Service Framework (WSF) was first released as part of the 5.3 platform release.

Not every SBO is designed to be projected as a web service, though. So, best practice documentation was published to the developer network, which for the most part just captures common sense. (I used to call these web service SBOs “WSBOs.”)

However, service-orientation at the time of D5.3 development was noticeably different than at the time of D6 development. There needed to be a way to target a broader base of existing service implementations (e.g. POJOs) into the realm of Enterprise Content Services.

Rather than controlling web services by insisting on a DFC/BOF (SBO) investment, it was clear that EMC Documentum needed to participate with broader business systems and processes. So, targeting plain old Java objects became a requirement, while also supporting DFC/BOF-based implementations for existing customers.

Rather than forcing service chains to align on content transfer approach, it was clear that EMC Documentum needed to support content transfer choice, empowering each link (service) in the chain to process content on its terms (e.g. as a file or as a stream).

At the same time, the 6.0 platform release provided additional facilities concerning distributed content. So, any new service-oriented offering from EMC Documentum needed to integrate with these facilities and increase their adoption via ease-of-use (integration).

Documentum Foundation Services (DFS) was first released as part of the 6.0 platform release and was designed to meet these, and several other, objectives.

Which brings us back to the .NET-oriented developer. How does DFS service these individuals?

• DFS provides an optional productivity layer
• DFS is based on open standards that Microsoft Visual Studio also supports (conclusion)

More on each approach, next…