DFS SOAP Request/Response – XML content over the wire

To watch the SOAP Request and Response being sent by DFS Clients, add the following code before the SOAP call.  I usually add it in the first few few lines of the main() method.
System.setProperty
(”com.sun.xml.ws.transport.http.client.HttpTransportPipe.dump”,
“true”);
This eliminates the need for using tools like TCPMon or Wireshark to observe what is being sent by DFS SDK.

Javascript Popup – Documentum DAM and WebTop

The credit for the solution goes to two people who work with me – Yih Wern and Su Sheng.

Problem: When the user goes to either Webtop or DAM URL, IE launches a separate popup window with the following messages:

appintgevents.js: AppIntgProcessEvent did not handle aiEvent(event=ShowDialog_,_id=invoker_,_title=Content Transfer Service_,_height=130_,_width=440_,_sizepreference=false)
appintgevents.js: AppIntgProcessEvent did not handle aiEvent(event=ShowBusyCursor)
appintgevents.js: AppIntgProcessEvent did not handle aiEvent(event=ShowBusyCursor)
appintgevents.js: AppIntgProcessEvent did not handle aiEvent(event=ShowBusyCursor)
appintgevents.js: AppIntgProcessEvent did not handle aiEvent(event=ShowBusyCursor)
appintgevents.js: AppIntgProcessEvent did not handle aiEvent(event=ShowBusyCursor)
appintgevents.js: AppIntgProcessEvent did not handle aiEvent(event=ShowBusyCursor)

This problem is irritating as the messages keep appearing repeatedly and the popup window is refreshed. In some extreme cases, the popup prevents people from logging in or viewing documents.

Solutions:
There seem to be two solutions.
1) If the user has Google toolbar installed, it could cause this issue.  You can test this by uninstalling the Google toolbar.  Or you can recommend the user to use older Google Toolbar.
2) The second solution is related to IE7  which tries to access a page – runonce.aspx.  This seems to fail for some browsers and leaves the registry in an inconsistent state.  To fix this you can do the following :  (Suggested by Yih Wern)
Run Registry.exe
search for: HKEY_CLASSES_ROOT\TypeLib\{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}\1.1\ZERO\win32  (WordPress is not displaying slash-zero.  Replace ‘ZERO’ with a numeric ‘0′)
Change the (Default) value from C:\WINDOWS\system32\shdocvw.dll to C:\WINDOWS\system32\ieframe.dll
Restart your IE browser.

The full thread is here – http://www.google.com/support/forum/p/Toolbar/thread?tid=1b384f23ae01da52&hl=en&fid=1b384f23ae01da52000462aedade69c6

Audit Trails and Impact on Documentum Performance

From my experience, we have to be careful about turning on audit trails in Documentum.  Turning on tracking for unnecessary events could lead to excessive audit trail creation in the database and will slow down the system.

For example, audit can be turned on for Sysobjects on several events. Two of these events are a bit confusing.

1) dm_getfile and 2) dm_fetch

While these two events sound similar at the first glance, their function is different.
1) dm_getfile occurs when a document is viewed or exported.  This is true “reading” of a document. You will want to turn this on to track which user downloaded/read this document.
2) dm_fetch occurs when webtop gets the documents attributes from the content-server.  This can occur when you perform a search or just browse to a folder.   This means that if you browse to a folder with 50 documents, it could potentially create 5o new audit trail records in the database!!  This is unnecessary, unless you have a strict security policy.

Watch out for this.  In our system, we turned on auditing for dm_fetch and ended up creating 8 million useless records and consuming all the database tablespaces.  After we realised what was happening, we turned off the auditing for dm_fetch and purged the unnecessary records, our system performance improved dramatically.

There are some excellent posts on EMC forums regarding this.  Do check them out.

Suggested Performance Testing Scenarios for Documentum (Webtop)

This is going to be a simple list:

- Login to Webtop (Due to authentication and display of cabinets/folders which involve ACL checks)
- Simple Search with 1 or 2 keywords (Due to FAST search engine and the ACL checks)
- Navigation to folders (object-list component could be very slow because of all the ACL checks, validation of actions, etc)
- Download a document (UCF can be slow)
- Upload a document (again UCF)

NOTE:
1) Rendering of HTML, Javascript, etc on a browser could take 1-3 seconds to display.
2) If you have Antivirus (Noticed with McAfee) which scans the HTML and .JS files, this will slow down the rendering further.

I will update this list if I come across any other scenarios.

View a Custom Attribute Value Assistance Fixed List using IAPI

sp_doc is the custom doctype and sp_indus is the attribute with a value assistance.

Enter the following command in the API Tester.  NOTE the “t” before the custom_type

dump,c,tsp_doc.sp_indus

map_display_string        [0]: Accountancy / Business, Finance & Law
                          [1]: Built Environment
                          [2]: Chemical & Life Sciences & Other Sciences
                          [3]: Engineering - Electrical & Electronics
                          [4]: Engineering - Mechanical / Manufacturing
                          [5]: Information Technology
                          [6]: Maritime Studies
                          [7]: Media & Design
  map_data_string         [0]: Indus01
                          [1]: Indus02
                          [2]: Indus03
                          [3]: Indus04
                          [4]: Indus05
                          [5]: Indus06
                          [6]: Indus07
                          [7]: Indus08
  map_description         [0]:
                          [1]:
                          [2]:
                          [3]:
                          [4]:
                          [5]:
                          [6]:
                          [7]:
  attr_name                  : sp_indus

Writing Performance/Load Testing Requirements

We are  in the middle of doing Performance testing on the project we are implementing with Documentum D6.  During the process I learnt that the requirements specs should be drafted very carefully when it comes to performance testing.   Here are some key points that may help you:

Define what the following terms mean in the context of  performance testing:
Concurrent users
Possible confusion here – Does it mean 500 users logged into the server and maintaining an idle session? OR 500 users logged in and performing active transactions?
Clearly specify that the performance testing shall be done with a sustained load of 500 concurrent users performing active transactions. There should not be any idle time between transactions except for the specified think-times.

Think-time
Think time is the time when the user is supposed to be reading documents or doing something that does not actively stress the system.
Obviously, using zero think time during performance testing will unduly load the system and is not realistic.  On the other hand, if you choose a think time that is too long, the system will not be tested correctly.
The think times chosen should be realistic.  Typically, 5-6 seconds between requests is a good start (since the user will get used to an application he uses frequently).  If you want to be accurate, time the actions of a few users which using a pilot/demo system.
If you are writing requirements specs you MUST specify a think time that you need your vendor to comply with.  Leaving this open is a sure way to arguments in future.

Response Time
Is this to be measured from user PC to server?  OR is it the time taken for the server to return a response to the load testing tool?
Usually performance testing is done using a tool like LoadRunner or Rational Performance Tester.   The tool will be setup on a test server(s) and run to generate the user load and perform transactions.  The are two problems to take note of here:
- The tool will send and receive data at a network level (TCP).   So the time taken by a typical browser to render the HTML, Javascript, etc is not recorded.
- The end-users will probably be accessing the application from different network locations.   The response time will depend on the network latency.
It is not possible to measure the network latency and browser render time accurately.  So you will need to make an assumption of this latency – say 4 seconds.
Finally, if you think your users can accept a response time of 8 seconds for a transaction, you will have to specify that using a tool like LoadRunner, the expected response time for the transation is 8-4 = 4 seconds.

Ramp-up period
Specify that 500 users shall be logged into the system within a period of 10 minutes.
You have two options after the user logs in.  1) Continue with the next transaction and logout after completion. OR 2) Login and wait until the load of 500 users has been attained. and only then start performing transactions.    Specify which of the above options you prefer.

Sustained user load
You must specify clearly that during the test period, the number of users logged into the system will be sustained at a level of 500 users. Users that complete transactions and logout will be replaced by logging in new users.  Otherwise, the system will be loaded initially but the user load will fall rapidly as the simulated users logout.

Caching
You cannot avoid caching in an enterprise system.
You should specify that caching caused by running the same search queries or downloading the same document should be eliminated. One way to achieve this is by randomly picking keywords or documents to download.
You can also use pacing creatively to avoid logging in the same user at short intervals.

Response Time measured at 95% (or 99%) Percentile Value
Don’t use Average response time as a measure of acceptable response times.  The mathematical average tends to mask the actual response times.   An accepted measure is the 95th percentile value.
If you have 100 transactions, sort all the response times in ascending order, the value at the 95th position is the 95th percentile value.  In other words, 95% of the users will see a response time faster than or equal to the 95th percentile value.
However, don’t go by this number alone.  Plot a graph that shows (Response-time) Vs (Total No of users).  This will show you if the large number of users are clustered at fast response times or towards the longer response times.

Stable Test Runs
When you conduct performance testing at high loads, some of the transactions will fail.  This could be due to hung threads, lack of server resources or other factors.   However, if a lot of transactions fail, then perhaps the system is not stable enough.   Depending on your requirement, you should specify that a test run is considered stable and valid for analysis if a suitable percentage (say 95%) of the transactions succeed.

It is also advisable to investigate why the 5% of the requests failed.  This means that 5% of users will see errors.  If you are running a eCommerce application or a financial application then this is a substantial number of failed transactions and you may not be willing to accept this.

To be continued…..

UCF Challenges – Less common ones

The user is unable to use UCF while viewing existing documents or creating new documents.

A message will be displayed (in IE7) – Your browser does not support Java.

Causes and Solution:

1) Verify that the user has MS JVM or Sun JRE installed correctly on his PC.  I have seen situations where the user installed Sun JRE, set IE to use this JRE and a few days later, deleted the C:\Program Files\Java files.
FIX: Reinstalled the JRE
2) The user has disabled the IE Add-ons needed to launch the applets.  This is tricky because we usually don’t look here.
FIX: Verify that the addins are enabled from the “Manage Add-ons” console of IE

UCF Troubles

The UCF feature in Documentum seems to be a necessary evil.   I have had more complaints from our users regarding UCF than any other Documentum component.

The most common complaint is – It is DAMN slow to launch!!

I agree with the users.   Launching UCF in our organization’s environment takes around 50-70 seconds!!!

Imagine that you read around 20 documents at different times in the day and every time you want to read a document, you have to wait for 50 seconds. Can you imagine the wait while your browser displays a blank page?   No wonder the users complain about this.

After running several rounds of tests, we identified the factors that cause these really slow response times.
1) UCF uses Java JRE 1.5.x.  JRE needs time to initialize itself and load into memory before UCF kicks into action.  On a laptop with 1GB RAM and a reasonably fast CPU, JRE takes around 20-30 seconds to launch.
2) Another key factor is the presence of Anti-virus software on the user’s laptop.  Since AV will scan all the JRE related .jar files, the JRE initialization will be further slowed slowed down.

From our tests,  (Only the first operation after browser restart takes this long. Next operations should finish between 10-15 seconds)
- Export operation using UCF with Anti-virus takes around 50-70 seconds
- When Anti-virus is turned off, the Export operation takes around 35-45 seconds.

Some suggestions:
- Tune your anti-virus settings to exclude JRE folders and UCF folders
- Exclude anti-virus from scanning into .zip and archive files
- TEST with various settings

Here are some of the other common problems with UCF:
- JRE gets updated automatically when a new update is available from sun.com.  Sometimes this breaks the UCF.  Solution could be to try deleting all the UCF related folders and files in UCF folder (usually found in C:\Documents and Settings\Documentum\ucf)

Customers who are planning to use Documentum should test the performance of UCF in their environment.
1) Setup a pilot environment on a test server.  Access Webtop from a typical end-user PC and check the response times.  Make sure you are running anti-virus and any other software that are standard to your environment.  This is one way to ensure that the system performance will be acceptable to the end-users.
2) If you are planning to conduct any peformance testing and load testing, ensure that you specify that some scenarios include testing with UCF enabled.

ANT version clash with Documentum and DFS

I was compiling the DFS samples uisng the ANT build file provided with the EMC SDK download.  I hit an error with ANT version while running the “ant artifacts” target.  I downloaded a fresh binary of ANT 1.6.5 from Apache website.  But I kept getting the same error.

Invalid implementation version between Ant core and Ant optional tasks.
core    : 1.6.2
optional: 1.6.5

The reason seems to be due to the fact that dctm.jar contains a MANIFEST.MF file which in turn has a reference to (older) ANT jar files.
Shared/ant.jar Shared/ant-ext.jar Shared/ant-launcher.jar

Solution:

Check all your class paths for any JAR files that may have a manifest file which refers to old versions of ANT jar files.

- Remove dctm.jar from the CLASSPATH.
- Add the individual jar files from – D:\Program Files\Documentum\Shared to the CLASSPATH.
- Exclude the – ant.jar, ant-ext.jar and ant-launcher.jar files from the CLASSPATH

set DCTM_SHARED=D:\Program Files\Documentum\Shared
%DCTM_SHARED%\activation.jar;%DCTM_SHARED%\admin.jar;%DCTM_SHARED%\All-MB.jar;%DCTM_SHARED%\AMService.jar;%DCTM_SHARED%\aspectjrt.jar;%DCTM_SHARED%\bpmutil.jar;%DCTM_SHARED%\bsf.jar;%DCTM_SHARED%\castor-0.9.5.2.jar;%DCTM_SHARED%\certjFIPS.jar;%DCTM_SHARED%\ci.jar;%DCTM_SHARED%\collaboration.jar;%DCTM_SHARED%\commons-jxpath-1.1.jar;%DCTM_SHARED%\commons-net-1.2.1.jar;%DCTM_SHARED%\ctsTransform.jar;%DCTM_SHARED%\ctsTransformImpl.jar;%DCTM_SHARED%\dam_services.jar;%DCTM_SHARED%\Dart.jar;%DCTM_SHARED%\DDS.jar;%DCTM_SHARED%\dfc.jar;%DCTM_SHARED%\dfcbase.jar;%DCTM_SHARED%\DmcPolicyEngine.jar;%DCTM_SHARED%\DmcRecords.jar;%DCTM_SHARED%\DmcRps.jar;%DCTM_SHARED%\dms-client-api.jar;%DCTM_SHARED%\IDmcPolicyEngine.jar;%DCTM_SHARED%\IDmcRps.jar;%DCTM_SHARED%\IDmcRpsModules.jar;%DCTM_SHARED%\jaxb-api.jar;%DCTM_SHARED%\jaxb-impl.jar;%DCTM_SHARED%\jsafeFIPS.jar;%DCTM_SHARED%\jsr173_api.jar;%DCTM_SHARED%\learningservices.jar;%DCTM_SHARED%\log4j.jar;%DCTM_SHARED%\messageArchive.jar;%DCTM_SHARED%\messageService.jar;%DCTM_SHARED%\offline.jar;%DCTM_SHARED%\serializer.jar;%DCTM_SHARED%\subscription.jar;%DCTM_SHARED%\Widgets.jar;%DCTM_SHARED%\workflow.jar;%DCTM_SHARED%\wstools.jar;%DCTM_SHARED%\xalan.jar;%DCTM_SHARED%\xercesImpl.jar;%DCTM_SHARED%\xforms.jar;%DCTM_SHARED%\XformsCommon.jar;%DCTM_SHARED%\xml-apis.jar;%DCTM_SHARED%\xmlParserAPIs.jar;%DCTM_SHARED%\xtrim-api.jar;%DCTM_SHARED%\xtrim-server.jar;

set CLASSPATH=%PROJECT_FOLDER%;%DCTM_SHARED_CLASSPATH%

OneNote and Autohotkey – Useful Scripts

I have been tinkering with Microsoft OneNote 2007 of late. I love its simplicity and features, but hate the fact that it does not support some of the common formatting hotkeys available in other Office Apps. So here are my Autohotkey scripts that provide a good substitute. Hope you will find them useful.

;CTRL+SHIFT+P activates the Font-size drop-down. 

#IfWinActive, ahk_class Framework::CFrame

^]:: ;Increase font-size

Send, {CTRLDOWN}{SHIFTDOWN}p{SHIFTUP}{CTRLUP}{DOWN}{ENTER}

return

 

^[::  ;Decrease font-size

Send, {CTRLDOWN}{SHIFTDOWN}p{SHIFTUP}{CTRLUP}{UP}{ENTER}

return

 

^Space::  ; Reset the font style to normal

Send, ^c

;Set Font-size to 11

Send, {CTRLDOWN}{SHIFTDOWN}p{SHIFTUP}{CTRLUP}11{ENTER}

;This just removes the formatting and pastes again

;This can be improved further

wholeclipboard:=ClipboardAll

Clipboard=%Clipboard%

Send,^v

Clipboard:=wholeclipboard

return

 

^t::  ;Show borders of tables

Send, {ALTDOWN}b{ALTUP}h

return

 

!1::  ;Set Heading Style

Send, {CTRLDOWN}bu{CTRLUP}{CTRLDOWN}{SHIFTDOWN}p{SHIFTUP}{CTRLUP}15{ENTER}

return

 

!2::  ;Set Heading Style

Send, {CTRLDOWN}b{CTRLUP}{CTRLDOWN}{SHIFTDOWN}p{SHIFTUP}{CTRLUP}12{ENTER}

return

 

^h::  ;High light selection in Yellow

Send, {CTRLDOWN}{SHIFTDOWN}p{SHIFTUP}{CTRLUP} ;This will highlight the font-size

Send, {TAB  9}{ENTER} ; Moves to the highlight box and sends enter to highlight

return

#IfWinActive