Tag Archives: DFS

Documentum Foundation Services

EMC Documentum Developer Edition

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.

Content-enabled applications empathized

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!

Addressing MaxReceivedMessageSize issues

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 2147483647 (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).

Building content-enabled applications

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…          Orlando, FL - May17-21

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.

Updated DFS Developer Guide on EDN

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!