Creating DFS Services using Documentum Composer

Document directory

• Creating a Service Consumer
• Building a Service
• Testing the service
• In Summary

From:Http://paulcwarren.wordpress.com/2008/08/11/creating-dfs-services-using-documentum-composer

I'm not sure how many people realize it but when you create a Documentum "artifact" project within composer, it is also a "dfs services" project. if you right click one of your Documentum projects and bring up its properties, then select the Java Build Path, then the Libraries tab you shoshould see something similar to this :-

An if you select Properties-> Builders, you shoshould see something like this :-

When an "artifact" project is created it also adds all the necessary DFS resources to allow you to develop Documentum services. it will deploy a copy of the dfs sdk to your core project (incidentally this is why creating the first project in a workspace takes a little longer than you might wrong CT) and add the DFS Services Library to your project's java build path. and add a DFS Builder for building your services.

Creating a Service Consumer

Just as a quick aside if you do need to create a consumer, select the "DFS Services Library" entry and then select Edit, you shoshould see something like this :-

As you can see there are in fact 4 flavors of DFS services library. the first, and the default, is concerned with developing services (today's topic ). the remaining three are actually concerned with developing service consumers. they are pretty self-explanatory. the only one that perhaps requires a little explanation is the last; "DFS Local Client ". you add this type of library to projects that are acting as "functional tests" for your services projects. typically, you create one or more of these "functional test" projects in the same workspace as your services projects and configure them with this type of library. this then allows you to debug from the client into the service and back again without having to deploy to a server. A useful feature. I will talk more about developing service consumers in a future articles.

Building a Service

OK, so back to developing the services themselves. as you can see your project is all set up for service development. now you need to develop a service. as you will probably all be aware there are a couple of flavors of DFS service; one based on a POJO and another based on a bof sbo (service-based object ). they are, in fact, very similar and are just annotated java classes. you can read more about DFS and its annotations from the DFS developer's guide. I won't go into these here. we'll use the POJO variant here. and for convenience we're re going to use one of the samples provided in the dfs sdk; <dfs sdk install dir>/samples/HelloWorldService. all we need to do is navigate to <dfs sdk install dir/samples/HelloWorldService/src/service folder and copy the top level folder of the source tree, "com" in this case. then paste it into the/Web Services/src folder of your Documentum project.

Once you drop these sources packages and class files into the Web Services folder, and assuming that you have "automatic build" turned on, then you shoshould see the DFS Builder leap into life and attempt to build the service. in your Console view you'll get a build report :-

And if you open the standard Navigator view (Window-> Open View-> Navigator) and navigate to the Web Services/bin/gen-src folder you shoshould also see a set of generated source. this is actually a JAX-WS web service that has been generated from your POJO service. and under the classes folder you shoshould see a set of classes and wsdl. these classes are an aggregate compilation of your POJO (and associated classes) and the generated jajax-ws web service. the wsdl is obviusly just standard wsdl also generated from your POJO :-

If for some reason your service fails to compile then you will of course get all the same familiar productivity tools for dealing with these issues that you have for plain old java development. for example you'll get errors and warnings reported in your Problem view :-

And just so you know the DFS Builder does support incremental builds and will only rebuild services that have changed since the last build so it shoshould be reasonably efficient.

Testing the service

So now we 've reached the point where we have a service that needs testing. there are two approaches to this. the first is to create a parallel test project with Junit tests that exercise your service. to facilitate this your test project wocould be configured with the local client library, as described above, so that it can make local invocations to your service. this project shoshould of course be placed under the same version control as your services project.

The second approach is to export your services as an ear, deploy it to an application server and exercise your service again via another project capable of making remote service invocations. before you do this though you must remember to set the archive's context root and module name as both of these affect the eventual URL of your service. this is a one time deal though so just right-click on the project and select Properties-> Documentum Project-> DFS Module :-

Just so you are aware. typically all emc dfs services share a context root of "services" and a module name that describes their general function. core for core services, bpm for business process, etc. these will then be available via URLs such as http: // localhost: 8080/services/core... And http: // localhost: 8080/services/bpm...

Once these settings are made you can export the service. Right-click on the project and select Export-> Documentum-> Export Service Archive :-

The archive name and context root shoshould be defaulted for you from your DFS Module settings page. choose an output folder. uncheck the Generate Publish Manifest. this is only required is you want to publish your services to a UDDI registry using the DFS tools. and click finish. this will produce your ear file. once you are in possession of the ear you can deploy it onto your app server using the ap Propriate app manager console or by dropping it into the hot deploy folder. whichever works for you. once you have it deployed you can perform a quick sanity check by requesting the service's WSDL document by requesting something like http: // localhost: 8080/services/helloworld/HelloWorldService? Wsdl. Assuming you get back the WSDL document (that matches the one that was generated by the builder earlier) then you are good to go.

Next you will need to create yourself another test project. but this time configure it with one of the two available Remote Client library options, depending on your content transfer requirements. again, creating Junit test cases I find is the quickest and easiest. these can be rolled up into test suites and all can be invoked easily enough through the Composer (eclipse) UI. and once again, if you can standardize this process has SS your development team then you can check this test project into source control right along side your services project.

In Summary

In summary we have passed ed through the out-of-the-box capabilities of a Documentum project with respect to creating DFS services. every Documentum project has the capability to host the development and testing of DFS services. there are four libraries that are at your disposal for development and testing. each project has an incremental builder that is capable of automatically building your services. and finally there is an exporter that can produce an ear file containing your services that is ready for deployment onto any app server.

Looking forward, in future articles I will talk more about another development option which leverages both Composer's and WTP's capabilities. this option gives you far greater control over the contents of your ear and brings remote debugging of your services to your IDE.

In the meantime, happy Composing.

Possibly related posts: (automatically generated)

• Hot Topics from EMC World 2008: CMA Edition

When e posts in the same categories:Documentum Foundation Services, composer, content management, dfs, documentum, documentum composer, ecm