Redpaper
Axel Buecker
Eddie Hartman
Eduardo Patrocinio
Jan Erik Hoel
Creating IDML Discovery Books with IBM
Tivoli Directory Integrator
Overview
IBM® Tivoli® Application Dependency Discovery Manager (TADDM) is a powerful tool for
discovering and classifying information about hardware and software assets, along with their
relationships and dependencies. In spite of automatic discovery features, you may find
yourself having to extract additional data from files, databases, and other sources,
reformatting it and writing it out as Identity Markup Language (IDML)1 files that Tivoli
Application Dependency Discovery Manager can import. IDML is the Extensible Markup
Language (XML) dialect used to describe Configuration Items (CIs) and their relationships
according to the Common Data Model (CDM)2. Processes that create these IDML import
files are called Discovery Library Adapters (DLA) and the fastest way to create a DLA is by
using IBM Tivoli Directory Integrator (TDI).
IBM Tivoli Directory Integrator is an integration toolkit that lets you visually assemble data
flow rules (called AssemblyLines) that control how data moves and is transformed between
any number of systems, transports, and data stores. Each AssemblyLine can perform data
filtering and re-formatting to fit output schemas.
The purpose of this IBM Redpapers publication is to show you how to create an
AssemblyLine that produces IDML import files for Tivoli Application Dependency Discovery
Manager. Along the way you can gain some skills that help you meet other integration
challenges as well.
1
2
To enable data import into IBM Tivoli Change and Configuration Management Database (CCMDB) from virtually
any source, IBM developed the Identity Markup Language.
The CDM is a hierarchy of classes that describe types of assets, their properties, and their relationships to one
another. It is a data model shared by several IBM products, including Tivoli Application Dependency Discovery
Manager. CDM is based on the unified modeling language (UML). For more information refer to the IBM Redpaper
publication IBM Tivoli Common Data Model: Guide to Best Practices, REDP-4389.
© Copyright IBM Corp. 2009. All rights reserved.
ibm.com/redbooks
1
Prerequisites: What you already should know
You will need an understanding of how information is organized in Tivoli Application
Dependency Discovery Manager, for example, CIs and relationships, since you will be writing
these objects out to your own IDML import files. If you are unsure which CDM CI types or
relationships to use, here are some options:
򐂰 The Tivoli Application Dependency Discovery Manager development team has created a
set of examples to illustrate how the IDML should look for several common types of
Configuration Items, both hardware and software CIs. This document is available via the
Tivoli Opal Web site at the following location:
http://www.ibm.com/software/brandcatalog/portal/opal/details?catalog.label=1TW10CC22
See “Understanding IDML and the CDM” on page 29 for more information about how to
leverage this document to make your own DLAs.
򐂰 You can also drop a question in the Tivoli Directory Integrator user forum:
http://groups.google.com/group/ibm.software.network.directory-integrator
Tivoli Directory Integrator users use the forum to exchange advice, lessons learned, and
code for a wide variety of scenarios. Chances are that someone else has already done
something similar to what you plan to do.
򐂰 Or you can search the Tivoli OPAL Web site for relevant solutions and documents:
http://www.ibm.com/software/tivoli/opal
In addition, you must download and install Tivoli Directory Integrator. Note that Tivoli Directory
Integrator is very lightfooted, so the installation only takes a few minutes and you should
simply accept the default installation settings. If you decide not to, then make a note of where
the Tivoli Directory Integrator program files are kept, as well as which path you chose for your
Solution Directory. The Solution Directory is where your project files are kept, and this area
should be included in your backup routine.
Be sure to keep your Tivoli Directory Integrator installation at the latest patch level. Updates,
readme information, and download links can be found here:
http://www.ibm.com/support/docview.wss?rs=697&context=SSCQGF&dc=DA400&uid=swg27010509&loc=en
_US&cs=UTF-8&lang=en&rss=ct697tivoli
Also, there is no need to worry about the Tivoli Directory Integrator installer adversely
affecting your machine. It simply lays down files into a self-contained directory structure,
including its own private Java™ environment. In fact, you can actually zip up a Tivoli Directory
Integrator installation and unzip elsewhere to move it.
Once Tivoli Directory Integrator is installed, spend at least an hour working through the IBM
Tivoli Directory Integrator 6.1.1:Getting Started Guide, GI11-64803:
http://publib.boulder.ibm.com/infocenter/tivihelp/v2r1/topic/com.ibm.IBMDI.doc_6.1.1/getting
started.htm
After completing the Getting Started exercises, spend another couple of hours on the first
seven video tutorials found here:
http://www.tdi-users.org/twiki/bin/view/Integrator/LearningTDI
Once completed, these exercises should give you enough familiarity with the Tivoli Directory
Integrator interface to enable you to follow the remainder of this guide.
3
2
Each Tivoli Directory Integrator manual is available as a PDF download to facilitate offline usage.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
Specifically, you will be familiar with Tivoli Directory Integrator concepts like AssemblyLines
(abbreviated as AL here and in other Tivoli Directory Integrator literature), Attribute Maps, and
AL components like Connectors, Functions, Parsers, and Loops.
You also need a copy of the IDML and Tivoli Application Dependency Discovery Manager
components for Tivoli Directory Integrator. Links to the necessary files are included in the
following sections.
Finally, in order to load and test your finished IDML Discover Book, you need access to a
running Tivoli Application Dependency Discovery Manager server.
Tivoli Directory Integrator interface setup
If you want your Tivoli Directory Integrator screens to look just like those in this document
(and avoid some less attractive side-effects of the default Java Swing settings) then execute
the following steps in the Tivoli Directory Integrator Config Editor (Figure 1):
1. Select File → Edit Preferences.
2. In the Appearance → General tab:
a. Change View Type to Tabbed from the drop-down list.
b. Check the top two check boxes.
3. In the Appearance → Look & Feel tab change Look & Feel4 to Metal from the drop-down
list. This is a cleaner and easier-to-navigate option.
4. In the misc settings tab set Execute Task Lines5 to 40000. This is a Java Swing buffer
that should be bigger than just 400.
Figure 1 Tivoli Directory Integrator interface setup
4
5
The Metal Look & Feel is a better implementation, at least under Windows®.
This is a Java Swing buffer size that should be increased.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
3
Creating a DLA to load data into Tivoli Application Dependency
Discovery Manager
You mission is to load the data in Example 1 with computers (host names) and their
associated operating systems into Tivoli Application Dependency Discovery Manager
(Example 1).
Example 1 Example data sets
machine,op_sys
troosevelt.my.com,Windows XP
taft.my.com,Red Hat Linux
wilson.my.com,Red Hat Linux
harding.my.com,AIX
coolidge.my.com,Windows XP
hoover.my.com,AIX
froosevelt.my.com,AIX
truman.my.com,AIX
eisenhower.my.com,AIX
kennedy.my.com,AIX
johnson.my.com,Windows XP
nixon.my.com,Red Hat Linux
ford.my.com,Windows XP
carter.my.com,AIX
reagan.my.com,Red Hat Linux
bush.my.com,AIX
clinton.my.com,AIX
You will do this by creating a Tivoli Directory Integrator AssemblyLine (AL) to transform the
above input information into an IDML file.
Preparation
To prepare for this exercise, you will need to do a couple of things:
1. Create a new folder in your Tivoli Directory Integrator Solution Directory named TADDM.
Next prepare the input data file for the exercise by downloading the file in the link below to
the new TADDM folder:
http://dl.getdropbox.com/u/375185/TADDM_IDML/MachineAndOS.csv
If for some reason you cannot reach the above link, simply create a text file and call it
MachineAndOS.csv and then copy-paste in the example data shown above.
2. Install the IDML components, downloading the package (complete with installation
instructions) from the Tivoli OPAL Web site here:
http://www.ibm.com/software/brandcatalog/PA_1_30000H0028BPF02BJ9MORU0000/Download
Redirector?u=null&i=1TW10CC16
Follow the steps listed in the release notes file to perform the installation.
4
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
Note: Instead of copying .jar files into the <TDI-install-folder>/jar sub-folders as
instructed in the release notes, we recommend that you create your own folder where
you can keep these separated from the standard installed Tivoli Directory Integrator .jar
files. However, this technique does not apply to files that must be copied to the
<TDI-install-folder>/jvm area.
To do this, create a directory called CustomJars under your Solution Directory and then
add a sub-folder called TADDM_IDML, placing the IDML .jar files here (again, except for
those that must go to the jvm/jre/lib/ext area).
Now edit the solution.properties text file found in your Solution Directory and remove
the number sign (#) that comments out the com.ibm.di.loader.userjars property. This
property line should appear near the beginning of the file. Set this property to point to
your CustomJars folder:
com.ibm.di.loader.userjars=CustomJars
Save the file and restart the Config Editor. Tivoli Directory Integrator is now able to find
the IDML library files.
Read the installation instructions thoroughly, since sometimes you also have to copy
files to folders like <TDI InstallDir>/jvm/jre/lib/ext (like DB server license files) or include
particular folders in the system path (for example, adding C:\Notes; to the SET PATH
command at the top of ibmditk.bat when you are integrating to Domino® through your
Local Notes client).
Creating the DLA AssemblyLine
Now we can begin to create our first AssemblyLine.
1. Once the components are in place, start the Tivoli Directory Integrator Config Editor and
create a new Tivoli Directory Integrator project, also known as a Config, by clicking the
Create new Config button (Figure 2).
Figure 2 Create new Config
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
5
2. Call this project myDLA.xml (Figure 3). Note that you must type in the .xml extension
yourself. Click OK to confirm.
Figure 3 Name your Config
You should now see the standard layout of a Tivoli Directory Integrator project, as
displayed in the Config Browser tree-view in the left part of the panel. There is a Config
node for controlling project-wide settings followed by one named AssemblyLines. This is
where your DLA ALs will appear as you implement them.
Below AssemblyLines are five more folders where the project library resources are kept,
with one folder for each type of Tivoli Directory Integrator component:
–
–
–
–
–
Connectors
Functions
Parsers
AttributeMaps
Scripts
There are four different Tivoli Directory Integrator IDML components, two Connectors, and
two Function Components (FCs):
IDMLConfigurationItem
IDMLReln
OpenIDML
CloseIDML
Connector used to create Configuration Items
Connector used to add relationships between CIs
FC used to open a new Discovery Book (IDML doc)
FC for closing an open Discovery Book
As you can see from the above list, the IDML FCs are for opening (creating) and closing
IDML Discovery Books, while the Connectors are what you use to write information to an
open Book. Your AL will be using all four of these components.
6
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
3. Right-click the AssemblyLines folder and select New AssemblyLine (Figure 4).
Figure 4 New AssemblyLine
4. Name your new AssemblyLine MyFirstDLA and click OK (Figure 5).
Figure 5 New AssemblyLine: Step 2
You now see an empty AssemblyLine details panel (Figure 6).
Figure 6 New AssemblyLine: Step 3
The Feeds section is typically the data pump of an AssemblyLine, containing an Iterator
mode Connector that reads in one entry at a time, driving data to the Flow section
components for processing. In other words, the Feeds section serves as an implicit
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
7
for-each loop that cycles the Flow section component for each entry read. You will have
seen this in the Getting Started and video tutorial exercises.
However, before your AL can start reading in data and writing to your Discovery Book, it
must first open it using the OpenIDML FC. Since there is no way to get the OpenIDML FC
to do this before the looping behavior of the Feeds section kicks in, you will not be able to
use this convenient feature. Instead, you must implement similar for-each logic inside the
Flow section using a Tivoli Directory Integrator Loop component.
Creating an IDML Discovery Book
As noted above, the first thing your AL must do is create and open your Discovery Book. Do
this by adding the OpenIDML FC to your AssemblyLine:
1. Right-click the Flow section folder and select Add Function Component. Choose the
idml.OpenIDML Function component (at the bottom of the selection list) and call it
OpenBook (Figure 7).
Figure 7 Creating an IDML Discovery Book
8
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
2. Click OK to confirm this and you will be presented with the configuration panel for the
OpenIDML Function component (Figure 8).
Figure 8 Creating an IDML Discovery Book: Step 2
Note: If for some reason you do not get the above Config panel it means that you did
not successfully install the required .jar files or that you did not restart the Tivoli
Directory Integrator Config Editor after performing the installation. Make sure that you
follow the ReleaseNotes.txt instructions precisely, and if the problem persists then
contact the Tivoli Directory Integrator support team at 1-800-IBM-SERV.
Table 1 is an overview of the OpenIDML FC parameters, along with the values, that you
will use6.
Table 1 OpenIDML FC parameter list
Open IDML FC parameter
Value
Application Code
This is the Application Code of the Management Software
System (MSS), consisting of an acronym for the source
application and its version number (for example, TDI6.1.1).
For this example use the value App1.0.
Refresh
Select this check box if the IDML that you are creating
represents new data or a full refresh, in which case Tivoli
Application Dependency Discovery Manager will create new
entries in its data store. If you leave this check box unchecked
then you are telling Tivoli Application Dependency Discovery
Manager to modify existing CIs and relationships using this
IDMLa.
You can leave this open for the exercise.
6
One of these parameters is shared between all IDML components: Book Name. Each pair of OpenIDML and
CloseIDML FCs must refer to the same Book, just as the Connectors used to write to a particular Book must be
configured with that Book’s name.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
9
Open IDML FC parameter
Value
Validate
Selecting this check box invokes the IDML validation feature of
this component.
Leave this unchecked for the time being.
Directory Name
Here you enter the full path to the directory where you want your
IDML Book file created.
Enter a valid folder on your machine. For example, write your
Book to C:\temp if this directory exists.
Book Name
The name that you give this Book and that all other components
associated with the same IDML must share.
Enter the value MyBook here.
Manufacturer Name
This parameter value is used in the creation of the Management
Software System name and should reflect the source of the
integration.
Use IBM for this example exercise.
Product Name
This parameter value is used in the creation of the Management
Software System name and should reflect the source of the
integration.
Use MyProduct for this example exercise.
Hostname
This parameter value is used in the creation of the Management
Software System name and should reflect the source of the
integration.
Enter host.ibm.com for this example exercise.
Detailed Log
All Tivoli Directory Integrator components have this flag.
Enabling it will result in verbose log output, facilitating
troubleshooting, and providing vital information for Tivoli
Directory Integrator support personnel.
Leave this check box open.
a. Note that if TADDM cannot find assets that match the incoming IDML, it will create new
entries anyway, as long as adequate information is included in the IdML.
3. Before adding any more logic to this solution, test that your component is working by
pressing the Run AL button located at the top right-hand corner of the AssemblyLine
details panel (Figure 9).
Figure 9 Test the AL
This causes the Tivoli Directory Integrator Config Editor to launch a new server, connect
through the API, and pipe across your Config. Furthermore, it instructs the Tivoli Directory
10
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
Integrator Server to run your AssemblyLine and then captures log output for display on
panel. Once your AssemblyLine has completed, the server shuts down.
Your AL should produce output similar to that shown in Example 2.
Example 2 AL test log output
[4:35:26 AM EDT] CTGDIC126I Waiting for incoming connection to
ServerSocket[addr=IBM-2AEEE2FCCF4/192.168.89.1,port=0,localport=2932].
Command Line Parameters:
[javaw.exe, -classpath, C:\Program Files\IBM\TDI\V6.1.1_GA\IDILoader.jar,
-Dlog4j.configuration=file:///C:\Program Files\IBM\TDI\V6.1.1_GA/etc/executetask.properties,
-Dos.name=Windows XP, -Djava.library.path=C:\Program Files\IBM\TDI\V6.1.1_GA\jvm\jre\bin;.;C:\Program
Files\IBM\TDI\V6.1.1_GA\jvm\jre\bin;C:\Program Files\IBM\TDI\V6.1.1_GA\libs;C:\Python24;C:\Program
Files\Support Tools\;C:\Program
Files\ThinkPad\Utilities;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\Program
Files\IBM\Infoprint Select;C:\Notes;C:\Program Files\XLView;C:\Utilities;C:\Program Files\IBM\Personal
Communications\;C:\Program Files\IBM\Trace Facility\;C:\WINDOWS\Downloaded Program Files;C:\Program
Files\ObjREXX;C:\Program Files\ObjREXX\OODIALOG; C:\Program Files\Stardock\Object Desktop\Object
Edit;C:\Program Files\ATI Technologies\ATI Control Panel;C:\Program
Files\ThinkPad\ConnectUtilities;C:\Program Files\Common Files\Adobe\AGL;C:\Program Files\Common
Files\Lenovo;C:\Program
Files\WinSCP3\;C:\PROGRA~1\IBM\SQLLIB\BIN;C:\PROGRA~1\IBM\SQLLIB\FUNCTION;C:\PROGRA~1\IBM\SQLLIB\SAMPLES\RE
PL;C:\Program Files\cvsnt;C:\Program Files\Rational\common;C:\IDWBWIN\bin;C:\Program
Files\QuickTime\QTSystem\;C:\Program Files\IBM\CMVCDC50;C:\Program Files\GnuWin32\bin;C:\Program
Files\IBM\CMVCDC50;C:\Program Files\Rational\Common, -jar, C:\Program
Files\IBM\TDI\V6.1.1_GA\IDILoader.jar, com.ibm.di.server.RS, -BAssemblyLines/MyFirstDLA, -SC:\Documents and
Settings\no010196\My Documents\TDI_pre7.0\myDLA.xml, -Ycom.ibm.di.config.xml.MetamergeConfigXML, -D, -R,
-Q2932, -b192.168.89.1]
04:35:31 CTGDIS232I Server is running in standard mode.
04:35:32 CTGDIS236I The stash file has been successfully read.
04:35:32 CTGDIS237I The key password is not present in the stash file. The keystore password will be used.
04:35:32 CTGDIS238I Server security has been successfully initialized.
04:35:33 CTGDKD445I Custom method invocation is set to false.
04:35:33 CTGDKD460I Generated configuration id 'C__Documents and Settings_no010196_My
Documents_TDI_pre7.0_myDLA.xml' for a configuration instance loaded from file 'C:\Documents and
Settings\no010196\My Documents\TDI_pre7.0\myDLA.xml'.
04:35:33 CTGDIS229I Register server: C:\Documents and Settings\no010196\My Documents\TDI_pre7.0\myDLA.xml.
04:35:33 Version : 6.1.1 - 2008-05-15
04:35:33 OS Name : Windows XP
04:35:33 Java Runtime : IBM Corporation, 2.3
04:35:33 Java Library : C:\Program Files\IBM\TDI\V6.1.1_GA\jvm\jre\bin
04:35:33 Java Extensions : C:\Program Files\IBM\TDI\V6.1.1_GA\jvm\jre\lib\ext
04:35:33 Working directory : C:\Documents and Settings\no010196\My Documents\TDI_pre7.0
04:35:33 Configuration File: <stdin>
04:35:33 CTGDIS785I --04:35:33 CTGDIS040I Loading configuration from stdin.
04:35:33 CTGDIS029I Starting AssemblyLine AssemblyLines/MyFirstDLA for debug.
CTGDIS589I Connect to 192.168.89.1: 2932
[4:35:33 AM EDT] CTGDIC127I Connection from Socket[addr=/192.168.89.1,port=2937,localport=2932].
[4:35:33 AM EDT] Remote Task Name: Thread-4
04:35:33 CTGDIS034I Wait for completion of AssemblyLine: AssemblyLines/MyFirstDLA.
04:35:33 CTGDIS255I AssemblyLine AssemblyLines/MyFirstDLA is started.
04:35:33 [OpenBook] Initalizing the Open IDML Function Component option appCode = App1.0
04:35:33 [OpenBook] Initalizing the Open IDML Function Component option dirName = C:\temp
04:35:33 [OpenBook] Initalizing the Open IDML Function Component option bookName = MyBook
04:35:33 [OpenBook] Initalizing the Open IDML Function Component option manufacturerName = IBM
04:35:33 [OpenBook] Initalizing the Open IDML Function Component option productName = MyProduct
04:35:33 [OpenBook] Initalizing the Open IDML Function Component option hostName = host.ibm.com
04:35:33 [OpenBook] Initalizing the Open IDML Function Component option validate = false
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
11
04:35:34 [OpenBook] Initializing Open IDML Function Component parameters done.
04:35:34 CTGDIS087I Iterating.
04:35:34 CTGDIS086I No iterator in AssemblyLine, will run single pass only.
04:35:34 CTGDIS092I Using runtime provided entry as working entry (first pass only).
04:35:34 CTGDIS088I Finished iterating.
04:35:34 [OpenBook] Closed IdML book App1.0.host.ibm.com.2008-09-26T08.35.34.031Z.xml
04:35:34 CTGDIS100I Printing the Connector statistics.
04:35:34
[OpenBook] CallReply:1
04:35:34 CTGDIS104I Total: CallReply:1.
04:35:34 CTGDIS101I Finished printing the Connector statistics.
04:35:34 CTGDIS080I Terminated successfully (0 errors).
04:35:34 CTGDIS079I AssemblyLine AssemblyLines/MyFirstDLA terminated successfully.
[4:35:34 AM EDT] AssemblyLines/MyFirstDLA
04:35:34 CTGDIS036I Exit after auto-run requested.
04:35:34 CTGDIS174I Config Instance C:\Documents and Settings\no010196\My Documents\TDI_pre7.0\myDLA.xml
exited with status 2.
04:35:34 CTGDIS228I Unregister server: C:\Documents and Settings\no010196\My
Documents\TDI_pre7.0\myDLA.xml.
04:35:34 CTGDIS627I TDI Shutdown.
************************
Process exit code = 0
Did you notice that even though you have not added the CloseIDML FC yet, the Book is
closed when the AL completes. In fact, there is no need to explicitly close the Discovery
Book unless the AssemblyLine is going to do something with it after it is closed, such as
automatically transfer it to the Tivoli Application Dependency Discovery Manager server,
as yours will soon be doing.
Note: Running your solution from the CE (particularly in the Debugger, as covered
later) is how you interactively build, test, and refine your AssemblyLines. For
deployment, the AssemblyLines will most like be started from the command line. We
will revisit this in “Running the DLA from the command line” on page 28.
Adding CIs
Now it is time to write data to your Discovery Book. To do this you first need to implement
some AL logic to loop through the input file. As mentioned before, since you cannot use
standard Feeds-Flow looping behavior, you must create your own.
1. Start by right-clicking the Flow folder again. This time select Add loop and call it FOR EACH
machine read. Once you click OK, the Loop details panel appears on panel.
12
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
Here you can see that there are three types of loop, as indicated by the radio buttons
across the top of the details panel. Keep the default setting of Connector Loop and attach
the Connector to use by clicking the Inherit from button (Figure 10).
Figure 10 Add a Connector Loop
2. Select the FileSystem Connector from the resulting selection drop-down (Figure 11).
Figure 11 Add a Connector Loop: Step 2
Once you have chosen it and clicked OK, the FileSystem Connector parameters are
shown in the Config tab of the Connector Loop.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
13
3. Enter the file path to the exercise data that you set up earlier in this section. Note that this
can be a relative path based on your Solution Directory, as shown in Figure 12.
Figure 12 Add a Connector Loop: Step 3
4. The FileSystem Connector needs a parser to interpret the structure of the incoming byte
stream. Configure this by clicking the Parser tab and then the Inherit from button at the
bottom right-hand corner of this tab. Choose CSV parser (Figure 13).
Figure 13 Add a Connector Loop: Step 4
14
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
5. By default, the delimiter for the Character Separated Value (CSV) parser is a
semi-colon (;). You must change the field separater to a comma so that it matches the
format of your exercise data7 (Figure 14).
Figure 14 Add a Connector Loop: Step 5
6. Now you can select the Input Map tab and click the Quick discovery button to read and
parse the file, which presents you with the list of available attributes (Figure 15).
Figure 15 Add a Connector Loop: Step 6
7
Since your data file already contains a first line specifying field names, you do not need to enter these yourself in
the Field Names parameter.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
15
7. Drag the attributes from the Connector Schema into the Input Map area. As you know,
these Input Map rules dictate which attributes the Loop Connector brings into the
AssemblyLine on each cycle—a fact that is also visible on panel since these attributes
now appear in the AL Work Entry list (Figure 16).
Figure 16 Add a Connector Loop: Step 7
8. The Connector Loop now cycles once for each line read and parsed from the CSV file. It is
time to add a Connector under the loop to write CIs that correspond to the input data. Do
this by right-clicking the loop and then selecting Add Connector component. Choose the
idml.IDMLConfigurationItem Connector from the list and call this new Connector
AddMachineCI8, as shown in Figure 17.
Figure 17 Add a Connector Loop: Step 8
8
16
The IDML Connectors only support AddOnly mode so you can leave this drop-down as it is.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
9. The IDMLConfigurationItem Connector has only two required parameters (Figure 18):
– The Class Type, where you specify the type of CI that you are creating. Enter the value
cdm:sys.ComputerSystem here for this exercise.
Note: In order to get Tivoli Application Dependency Discovery Manager to visually
categorize the these CIs, you would need to dynamically change the Class Type
parameter of the ConfigurationItem Connector to reflect the correct sub-class of
ComputerSystem, like LinuxUnitaryComputerSystem or WindowsComputerSystem.
Note that these sub-classes have been deprecated and will be removed from a
future release of the Common Data Model. However, in the meantime you control
visual organization of CIs in Tivoli Application Dependency Discovery Manager by
using these qualifying CDM Class Types.
Note that in order to implement this in Tivoli Directory Integrator, simply change the
Initialize drop-down at the top of the Connector Config tab to Initialize and
terminate each time and then click the label of the Class Type parameter and enter
the following into the Expression® field:
{work.ClassType}
Of course, prior to this you will need an Attribute map where you compute the value
of this ClassType Attribute, for example with a JavaScript™ map like this:
opsys = work.getString(“op_sys”);
if (opsys.startsWith(“Red Hat”))
ret.value = “cdm:sys.LinuxUnitaryComputerSystem”
else if (opsys.startsWith(“Windows”))
ret.value = “cdm:sys.WindowsComputerSystem”
else ...
– The Book Name, which must have the same value that you specified for the OpenIDML
Function component: MyBook.
Figure 18 Add a Connector Loop: Step 9
10.Now you must set up the Output Map for this Connector in order to transform the CSV
exercise data into the CI fields id, cdm:Signature, and cdm:Fqdn (fully qualified
distinguished name).
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
17
Starting with id, select the Output Map tab and drag in the machine attribute from the
Work Entry list into the Output Map. Double-click it in order to rename the attribute to id so
that it conforms to the IDML schema (Figure 19).
Figure 19 Add a Connector Loop: Step 10
As you can see from Figure 19, even though the attribute is written to the Discovery Book
with the name id, it still gets its value from the Work Entry Attribute called machine.
11.Drag machine again into the Output Map and this time rename it to cdm:Signature. Now
drag it over once more and this time call it cdm:Fqdn (Figure 20).
Figure 20 Add a Connector Loop: Step 11
Even though this is an example scenario, it is not uncommon that the same source attribute is
mapped to multiple output attributes.
Validating the IDML Book
It is time to test your work again. But before you do, select the OpenBook FC (OpenIDML)
and enable the Validate check box. Now that there is data in the Discovery Book, you will
want it validated. Do this now by clicking the Run button to test your AL again.
18
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
Your AssemblyLine produces output similar to what you saw in the previous test, with the
addition of a validation report, as shown in Example 3.
Example 3 Output from test AL
IBM Discovery Library Certification Tool
Version 2.4.4
===============================================================================
File: C:\temp\App1.0.host.ibm.com.2008-09-24T22.55.54.140Z.xml
===============================================================================
.
Certification tool found:
18 Managed elements
0 Relationships
[PASS]
[PASS]
[PASS]
[PASS]
[PASS]
[PASS]
[PASS]
-
TEST
TEST
TEST
TEST
TEST
TEST
TEST
00
01
02
03
04
05
06
(XML Parse)
(All MEs have a valid ID)
(superior reference IDs in book)
(Attributes are valid)
(All managed elements have a valid naming rule)
(All managed elements are valid)
(All relationships are valid)
Book passed all certification tests
Elapsed time: 4.2 seconds
You should also be able to find your newly created Discovery Book and open it in a browser
window to examine the contents. There should be one <cdm:sys.ComputerSystem> node
entry for each machine read from the input file.
Adding CI relationships
In addition to host names, the input data also contains information about each machine’s
operating system. This data must also be captured in your Discovery Book, as well as the
relationships between each machine and its OS.
1. Add another Connector by right-clicking the Loop and selecting Add Connector
component. Choose the idml.IDMLConfigurationItem Connector from the list and call
this new Connector AddOS, as shown in Figure 21.
Figure 21 Adding CI relationships
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
19
2. Operating systems are represented by a separate CI class in the Common Data Model
called cdm:sys.OperatingSystem, so set the Class Type parameter to
cdm:sys.OperatingSystem. The book name must, of course, be MyBook (Figure 22).
Figure 22 Adding CI relationships: Step 2
3. The cdm:sys.OperatingSystem class also needs an id value. Use the same Work Entry
Attribute that you did for the ComputerSystem by bringing up the Output Map for your
AddOS Connector, and dragging in the machine attribute and renaming it to id.
Since every CI must have a unique ID, you must modify the mapping rule slightly so that
the ID of the OperatingSystem is different from that of the associated ComputerSystem.
The simplest way to do this is by selecting the id Output Attribute and then changing the
Mapping Type from Simple to Expression (Figure 23).
Figure 23 Adding CI relationships: Step 3
4. Expression maps allow you to enter a literal text value, optionally including one ore more
substitution tokens. As soon as you select Expression mapping, Tivoli Directory
Integrator presents you with an Expression containing a token that is equivalent to the
original Simple map:
{work.machine}
20
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
Now you can ensure a unique OperatingSystem CI ID value by appending the text _os
(Figure 24) after the right-most curly brace of the substitution token:
{work.machine}_os
Figure 24 Adding CI relationships: Step 4
Note: This could also be done using the JavaScript Mapping Type option and then
entering the following snippet in the assignment editor:
ret.value = work.getString(”machine”) + "_os";
5. Now drag the op_sys Attribute from the Work Entry list into the Output Map and rename it
as cdm:OSName. Click the eyeball button above the Output Map and switch to List View
mode. This gives you a quick overview of your mapping assignments. The AddOS
Connector is now complete (Figure 25).
Figure 25 Adding CI relationships: Step 5
Note: You can run your AssemblyLine now and verify your work if you like, or you can
proceed with adding the installedOn relationship first. That is the beauty of Tivoli
Directory Integrator: You can continually test your solution as you incrementally build
and improve the logic of your AL.
Remember: Periodically save your Config with either the Ctrl+S keyboard shortcut, by
selecting the File → Save menu option, or by clicking the Save button in the main
button bar.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
21
6. Now that both CIs have been added, your AL can now write the relationship between
them. Do this by right-clicking the Loop again and selecting Add Connector component.
This time choose the idml.IDMLReln Connector. Call it AddRelationship and click OK to
confirm (Figure 26).
Figure 26 Adding CI relationships: Step 6
The IDMLReln Connector is similar to the IDMLConfigurationItem Connector that you
have been using already, with the exception that the ClassType parameter has been
replaced with Relationship Class Type.
7. The Relationship Class Type value that you should use here is cdm:installedOn. And,
once again, set the book name to MyBook (Figure 27).
Figure 27 Adding CI relationships: Step 7
Note: See whether you figure out how to add the other relevant relationship as well:
cdn:runsOn. Hint: You will need another idml.IDMLReln Connector.
8. Your last step here is to set up the two property values for this relationship:
– Source
– Target
The source of the relationship will be the OS and the target is the machine that it is
installed on.
Select the Output Map of your AddRelationship Connector and then drag in machine from
the Work Entry list. Double-click it and call it target. Now the value assigned to the target
attribute will be the same as the id of the ComputerSystem.
22
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
To specify the source for this relationship, drag in machine once more and rename it as
source. Now apply the same change to the mapping assignment as you did for the
OperatingSystem ID, in other words, this Expression map:
{work.machine}_os
If you use the eyeball button to switch to List View then your assignments should look like
Figure 28.
Figure 28 Adding CI relationships: Step 8
9. Now run your AssemblyLine again. If all goes well then your AL will create a new IDML
Book complete with CIs and their relationships, validating it as well. Once this is achieved
you are ready to transfer your Discovery Book to the Tivoli Application Dependency
Discovery Manager server.
Transferring the IDML file to the Tivoli Application Dependency Discovery
Manager Server
To securely transfer an IDML Book to the Tivoli Application Dependency Discovery Manager
server, another Tivoli Directory Integrator component is required. You can download the
package from OPAL at the following Web link:
http://www.ibm.com/software/brandcatalog/portal/opal/details?catalog.label=1TW10DI0C
Unpack the asset, place the FileTransferFC.jar in the same directory as the jar files from the
previously added FCs, and then restart the Tivoli Directory Integrator Configuration Editor. Be
sure to consult the release notes for any last-minute changes or notices.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
23
Once these preparations are complete, you can continue with your AssemblyLine.
1. The first thing that you must do is explicitly close the IDML Book. To do this, add a new
Function component to the Flow section, making sure that it appears after your Loop and
not under it. Choose the CloseIDML FC and call it CloseBook. This component has only a
single parameter, Book Name, which you set to MyBook (Figure 29).
Figure 29 Transferring the IDML file
The CloseIDML FC closes the Book and performs validation if this option is enabled in the
OpenIDML FC. It furthermore returns the filepath to the newly created XML document.
You need this in the final step when you pass the file to Tivoli Application Dependency
Discovery Manager for import.
2. To retrieve the book filepath, select the Input Map of your CloseBook FC and click the Add
new attribute button, as shown in Figure 30.
Figure 30 Transferring the IDML file: Step 2
24
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
3. Name this Attribute idml.bookName and click OK to confirm. Then double-click this
attribute and rename it as FileName so that it can easily be referenced in a Tivoli Directory
Integrator Expression9 (Figure 31).
Figure 31 Transferring the IDML file: Step 3
Because FileName is found in an Input Map, an Attribute called FileName now appears in
the Work Entry list. You are ready to add the FC that will transfer this file to Tivoli
Application Dependency Discovery Manager.
4. Right-click the Flow section folder and select Add Function Component. Choose
ibmdi.FileTransferFC and call it SendBook2TADDM. In the Config tab, set the parameters to
suit your Tivoli Application Dependency Discovery Manager environment, as shown in
Figure 32.
Figure 32 Transferring the IDML file: Step 4
Note that the Source file (local) parameter is left blank. This is because the IDML file name
is generated at run time by your OpenBook FC. Fortunately, the Source file parameter
value can be passed to the FC by mapping it out in a specially named attribute, source.file.
5. Go to the Output Map of the SendBook2TADDM FC and drag in the FileName attribute
from the Work Entry list. Now rename it to source.file, which is the name that the FC is
expecting.
9
If you click this attribute you see that it is still mapping its value from idml.bookName, which is what the CloseIDML
FC returns. You can rename the resulting Work Entry Attribute as desired, and in this case the goal is to make the
attribute name usable in a Tivoli Directory Integrator Expression. (The extra dot (.) in the original name would not
work.)
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
25
Since the Filename Attribute contains only the file name instead of its full path, you must
change the Map Type to Expression and include the path that you set for the OpenBook
FC10: C:/temp/{work.FileName}, as shown in Figure 33.
Figure 33 Transferring the IDML file: Step 5
6. Save your work.
If the FC has been correctly configured, when you click Run to test the AssemblyLine it
creates the IDML Book, validates it, and then transfers it to the Tivoli Application
Dependency Discovery Manager server.
Loading the IDML file into Tivoli Application Dependency Discovery Manager
The last element to be added to the AssemblyLine is the function to import the IDML into
Tivoli Application Dependency Discovery Manager. This is done by the execution of a
command on the Tivoli Application Dependency Discovery Manager server and can be
automated by adding the Remote Command Line Function Component to your
AssemblyLine.
1. Right-click the Flow section folder and select Add Function Component (Figure 34).
Figure 34 Loading the IDML file
10
26
Tivoli Directory Integrator lets you use forward or backwards slashes as you please, regardless of the platform
that your system is running on.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
2. Select the ibmdi.RemoteCmdLineFC Function Component, enter UpdateTADDM as the
name, and click OK.
The parameters must be configured as shown in Table 2.
Table 2 RemoteCmdLineFC parameters and values
RemoteCmdLineFC parameter
Value
Target Machine Hostname
The server running Tivoli Application Dependency Discovery
Manager.
Target Machine Hostname
The server running Tivoli Application Dependency Discovery
Manager.
Remote User
The ID of a user with the necessary access rights to run the
loadidml command on the Tivoli Application Dependency
Discovery Manager server.
Password
Password for the user ID specified above.
Connection Protocol
This selection is based on your environment and the platform
that Tivoli Application Dependency Discovery Manager is
running on, for example, WIN for a Windows Tivoli
Application Dependency Discovery Manager server.
Command
The full path to the loadidml command, including the –f
option and a path to the directory where the IDML file is
located (as set in the previous section on transferring the
IDML Book). Using the example of Tivoli Application
Dependency Discovery Manager running on a Windows
server again:
c:\ibm\cmdb\dist\bin\loadidml.bat -f c:\ibm\cmdb\dla
Note: Since the loadidml command will process all files
found in the directory where the command is run, a file name
is not needed as part of the command syntax.
3. Now when you click Run to test the full assembly line, the log output should look similar to
that in Figure 35.
Figure 35 Loading the IDML file: Step 3
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
27
4. In addition, you are able to see the new entries in the Tivoli Application Dependency
Discovery Manager GUI, as shown in Figure 36.
Figure 36 Loading the IDML file: Step 4
If you have the Tivoli Application Dependency Discovery Manager GUI open when you run
your AssemblyLine, you see the following status message at the bottom of the panel. Click
the message to update the view to see the added components.
Note: Although the servers that you just added will include the OS name as specified in
the CSV file, they will not be categorized correctly in Tivoli Application Dependency
Discovery Manager. To get correct placement in the Tivoli Application Dependency
Discovery Manager database, additional fields would have to be available in the CSV
file, or joined into the AL from other sources.
Running the DLA from the command line
As noted earlier, running the AssemblyLine from the GUI is the best way to test and debug.
However, in a production setup you would normally run the AssemblyLine from the command
line.
As an example of doing this under Windows, open a command prompt and navigate to your
Tivoli Directory Integrator folder (for example, C:\Program Files\IBM\TDI\V6.1.1). To run your
AssemblyLine, enter the following command:
ibmdisrv –c myDLA.xml –r MyFirstDLA
28
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
Note that if you run the ibmdisrv command with no arguments then you get a complete usage
message outlining the various options available to you, as shown in Example 4.
Example 4 ibmdiserv arguments
C:\Program Files\IBM\TDI\V6.1.1>ibmdisrv
Usage: ibmdisrv [OPTION]...
Allowable options are:
-c <file ...> Configuration files.
-d Run in daemon mode
-e Start the Server in secure mode.
-f <extProp1=file1,extProp2=file2 ...> External property files.
-i Ignore global properties file and read from solution properties file.
-l <file ...> Redirect Console output to specified log file.
-n <encoding> Encoding to be used when writing configuration files.
-p Dump java properties on startup.
-q <mode> mode=1 Run in record mode, mode=2 Run in playback mode
-r <al ...> List of AssemblyLine names to start. To start AssemblyLine a and b,
use the command -r a b.
-s <dir> Specifies the working directory where the solution is located. Must be
first option.
-t <eh ...> List of EventHandler names to start. To start EventHandler a and b,
use the command -t a b.
-v Show version information and exit. This is logged only in the logfile.
-w Wait for each AssemblyLine or EventHandler to complete before starting the ne
xt.
-D Disable startup of auto-started EventHandlers.
-P <password> Password if configuration file is encrypted.
-R Disable Remote API, ignoring the setting in global.properties.
-T Enable Performance logging
-W Never terminate the server
-Z Zero out checkpoint information and start checkpointed AssemblyLine from begg
inning
-? This message
-0 to -9 for user-defined parameters
Understanding IDML and the CDM
As its name implies, the Common Data Model is a shared model designed to allow easier
integration of the different systems that deliver service and asset management functionality
for the same services and assets. Once connectivity to the source data is no longer an issue,
your challenge will be to choose the correct class and relationship types for your IDML output,
as well as which property values to set and how to compute these. Examining samples of
IDML based on real-world data can help you in setting up these data mapping rules. There
are also JavaDocs available (and linked below) that document the various CDM classes.
These can provide the insight that you need to build your DLA.
Reading IDML samples
The Tivoli Application Dependency Discovery Manager development team has collected
several common examples into a single document entitled Using the Data Model to display
data in TADDM:
http://www.ibm.com/software/brandcatalog/portal/opal/details?catalog.label=1TW10CC22
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
29
This is where you start on your quest to pick the correct CDM CI and relationship types, as
well as discover their associated property values11. Every example in this guide includes a
sample IDML preceded by a brief description of what is modeled. Turn to the first example,
entitled Linux® Computer System and take a close look at the xml shown there.
The start of all Discovery Book XML defines the various IDML Book values like hostName
and manufacturerName. Skip down past all this to the XML nodes that represent CIs and
relationships. Here you see what the Output map of your IDMLConfigurationItem Connectors
will be creating (Example 5).
Example 5 XML example for a Linux-based system
...
<cdm:CDM-ER-Specification>
<cdm:sys.linux.LinuxUnitaryComputerSystem id="1" sourceToken="cs1">
<cdm:Label>computer1.austin.ibm.com</cdm:Label>
<cdm:SerialNumber>87BG943</cdm:SerialNumber>
<cdm:Model>IBM eserver xSeries 230 -[86464AX]-</cdm:Model>
<cdm:Manufacturer>IBM</cdm:Manufacturer>
<cdm:PrimaryMACAddress>000218ZZF223</cdm:PrimaryMACAddress>
<cdm:fqdn>tempo.us.ibm.com</cdm:fqdn>
</cdm:sys.linux.LinuxUnitaryComputerSystem>
<cdm:OperatingSystem id="2" sourceToken="os1">
<cdm:OSName>Red Hat ES 6</cdm:OSName>
<cdm:OSVersion>1.2.3.4.5</cdm:OSVersion>
</cdm:OperatingSystem>
<cdm:installedOn source="2" target="1"/>
<cdm:runsOn source="2" target="1"/>
...
From Example 5 you can see which attributes a CI-like LinuxUnitaryComputerSystem has, for
example, PrimaryMACAddress and Manufacturer. The relationships shown have only source
and target. Although these examples provide a great guideline for your DLA work in Tivoli
Directory Integrator, also consult the CDM JavaDocs.
The CDM JavaDocs
All CI and relationship class types are described in the CDM JavaDocs, linked here:
http://dl.getdropbox.com/u/375185/TADDM_IDML/model-javadoc.tar.gz
Just unzip this to a drive and then click the index.html file in the root folder.
You can tell much about which properties a class has by the get methods defined for it. For
example, the presence of a getFqdn() method indicates that there is an Fqdn property that
you can map out to.
Unique identifier (id)
The tutorial exercise in the preceding sections had you mapping out an id value for each CI
and relationship. As you can see from the sample, this becomes the xml attribute that
uniquely identifies a Configuration Item or relationship. The other attributes like cdm:fdqn and
cdm:OSName provide property values as required and defined for each class type.
11
30
Note that this document is updated periodically by the Tivoli Application Dependency Discovery Manager
development team.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
This leads to an interesting topic: Deciding what input value is to become the id of your CIs.
The id must uniquely identify each CI, and in the tutorial exercise you used the machine
attribute for the computer system and {work.machine}_os for its operating system. If the input
data had not provided you with a unique attribute, you could have used a snippet of
JavaScript in a map to make a unique value yourself, perhaps combining several input values.
Another approach is to use counters, for example, adding the first CI with an id mapping of
ret.value = counter and the next one with ret.value = counter+1. The above IDML looks like it
was created this way, with the first CI identified as 1, the second as 2, the third as 3, and so
forth.
It is important to remember that this id value is not the actual identifier of the CI that Tivoli
Application Dependency Discovery Manager created based on your IDML. Each CI has its
own internal unique identifier assigned to by Tivoli Application Dependency Discovery
Manager when it was imported. So the question comes to mind: What happens if I load the
same import file twice? Will this update the CIs created during the first import, or will it create
duplicates?
Naming rules
To answer this question, you first must understand the concept of naming rules in the CDM.
Look at the JavaDoc page of LinuxUnitaryComputerSystem. This page describes what is
special about a LinuxUnitaryComputerSystem CI, in addition to all the methods and
properties that it inherits from other more generic CI classes. Since the header of this page
does not contain a section called Naming Rules, you will need to look at its direct ancestor to
see if naming rules are defined here instead.
public interface LinuxUnitaryComputerSystem
extends UnitaryComputerSystem
Clicking the UnitaryComputerSystem link brings up its JavaDoc page. As you can see, there
are no naming rules listed here either. Continue up the hierarchy.
public interface UnitaryComputerSystem
extends ComputerSystem
Finally, at the ComputerSystem level you find the naming rules that apply to this class and all
its descendants, along with a bit more information that will come in handy:
public interface ComputerSystem
extends CIMSystem, ConfigurationItem
򐂰 Naming rules:
– 0="signature" 1="-VMID,manufacturer,model,serialNumber" 2="systemBoardUUID"
– 3="primaryMACAddress" 4="hostSystem,VMID" 5="managedSystemName"
– 6="VMID,manufacturer,model,serialNumber"
򐂰 Persistable: true
򐂰 Table Name: COMPSYS
򐂰 Top Level: true
򐂰 Display Name: fqdn
The naming rules above state that first Tivoli Application Dependency Discovery Manager
looks for a signature property value in this CI. If found, it is used to uniquely identify this CI.
Otherwise, the next naming rule is applied (#1). It states that if no VMID property is defined
(-VMID) then the manufacturer, model, and serialNumber will be used combined for
identification. If one or more of these attributes is missing then rule #2 is applied, and so forth.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
31
You must determine which naming rules you can satisfy with the input data that you must
work with, especially if you plan to trick-feed Tivoli Application Dependency Discovery
Manager with updates as the source data changes.
Conclusion
Congratulations. You have just created your first Tivoli Directory Integrator DLA. Once in Tivoli
Application Dependency Discovery Manager, information about CIs and their relationships
can be moved to CCMDB to enable ISM services like Tivoli Service Request Manager
(TSRM). There are also additional Tivoli Directory Integrator components available on OPAL
for searching and extracting Tivoli Application Dependency Discovery Manager data in order
to drive it to, or synchronize it with, targets like reporting systems, databases, and even text
files, or simply to augment data in other AL flows.
And this is only the beginning. As mentioned in the introduction, Tivoli Directory Integrator is
part of a growing number of IBM products and offerings, and you will find the skills that you
just gained invaluable across a wide range of development and deployment scenarios.
There are a number of resources available to help you build your Tivoli Directory Integrator
expertise, and a good place to start is with this video tutorial on the AssemblyLine
Debugger12:
http://www.ibm.com/software/brandcatalog/portal/opal/details?catalog.label=1TW10DI06
This uniquely powerful feature lets you interactively step through the execution of your
AssemblyLines, visually controlling your transformation and flow-control logic, and both
viewing and modifying data in-flight—even if the AL is running on a remote platform.
You will also want to understand how to make your ALs more robust by through error
handling:
http://www.ibm.com/software/brandcatalog/portal/opal/details?catalog.label=1TW10DI0B
The team that wrote this IBM Redpaper
This paper was produced by a team of specialists from around the world working with the
International Technical Support Organization, Austin Center.
Axel Buecker is a Certified Consulting Software IT Specialist at the International Technical
Support Organization (ITSO), Austin Center. He writes extensively and teaches IBM classes
worldwide on areas of software security architecture and network computing technologies. He
holds a degree in Computer Science from the University of Bremen, Germany. He has 22
years of experience in a variety of areas related to workstation and systems management,
network computing, and e-business solutions. Before joining the ITSO in March 2000, Axel
worked for IBM in Germany as a Senior IT Specialist in Software Security Architecture.
Eddie Hartman is part of the Tivoli Direcory Integrator development team and has worked
with the tool since its inception. In addition to design, documentation, community outreach,
and enablement, Eddie writes extensively on how to integrate many types of IBM products.
You can read his thoughts on TDI at http://tdiingoutloud.blogspot.com/.
12
32
All video tutorials, including exercise data files, presentations and sample Configs can be found in the Tivoli
Directory Integrator community Web site: http://www.tdi-users.org.
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
Eduardo Patrocinio is a Senior IT Architect in the IBM Tivoli Advanced Technology Group in
the USA. He has over 15 years of software development experience, with expert-level
credentials in the areas of database design and warehousing, network management, service
desk tools, service level management, and CMDB design. He is a principal consultant to
internal IBM development groups on CMDB and ITIL® process-management requirements.
Over the last three years he has implemented IT service management solutions for more than
50 customers in over 20 countries. His current focus is on the practical application of CMDB
and configuration management to IT service management and ITIL-based initiatives. His
academic credentials include his selection as Engineering Student of the Year 1993 for the
country of Brazil, based on country-wide testing and interviewing of students throughout the
country.
Jan Erik Hoel is a Senior IT Specialist with IT experience back to the late seventies, currently
working in IBM Tivoli Software Services in Norway. For the last 12 years he has been working
with software distribution, remote control, and inventory. One of his major projects recently
was the distribution solution developed for the Norwegian State Lottery (Norsk Tipping)
including a Web-based front-end to the base Tivoli solution (Tivoli Configuration Manager). In
recent years, Tivoli Provisioning Manager, Tivoli Application Dependency Discovery Manager,
Tivoli Directory Integrator, and IBM Tivoli Monitoring have been added to the skill set.
Thanks to the following people for their contributions to this project:
Julie O’Shea, Editor
International Technical Support Organization, Poughkeepsie Center
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
33
34
Creating IDML Discovery Books with IBM Tivoli Directory Integrator
Notices
This information was developed for products and services offered in the U.S.A.
IBM may not offer the products, services, or features discussed in this document in other countries. Consult
your local IBM representative for information on the products and services currently available in your area. Any
reference to an IBM product, program, or service is not intended to state or imply that only that IBM product,
program, or service may be used. Any functionally equivalent product, program, or service that does not
infringe any IBM intellectual property right may be used instead. However, it is the user's responsibility to
evaluate and verify the operation of any non-IBM product, program, or service.
IBM may have patents or pending patent applications covering subject matter described in this document. The
furnishing of this document does not give you any license to these patents. You can send license inquiries, in
writing, to:
IBM Director of Licensing, IBM Corporation, North Castle Drive, Armonk, NY 10504-1785 U.S.A.
The following paragraph does not apply to the United Kingdom or any other country where such
provisions are inconsistent with local law: INTERNATIONAL BUSINESS MACHINES CORPORATION
PROVIDES THIS PUBLICATION "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR
IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF NON-INFRINGEMENT,
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Some states do not allow disclaimer of
express or implied warranties in certain transactions, therefore, this statement may not apply to you.
This information could include technical inaccuracies or typographical errors. Changes are periodically made
to the information herein; these changes will be incorporated in new editions of the publication. IBM may make
improvements and/or changes in the product(s) and/or the program(s) described in this publication at any time
without notice.
Any references in this information to non-IBM Web sites are provided for convenience only and do not in any
manner serve as an endorsement of those Web sites. The materials at those Web sites are not part of the
materials for this IBM product and use of those Web sites is at your own risk.
IBM may use or distribute any of the information you supply in any way it believes appropriate without incurring
any obligation to you.
Information concerning non-IBM products was obtained from the suppliers of those products, their published
announcements or other publicly available sources. IBM has not tested those products and cannot confirm the
accuracy of performance, compatibility or any other claims related to non-IBM products. Questions on the
capabilities of non-IBM products should be addressed to the suppliers of those products.
This information contains examples of data and reports used in daily business operations. To illustrate them
as completely as possible, the examples include the names of individuals, companies, brands, and products.
All of these names are fictitious and any similarity to the names and addresses used by an actual business
enterprise is entirely coincidental.
COPYRIGHT LICENSE:
This information contains sample application programs in source language, which illustrate programming
techniques on various operating platforms. You may copy, modify, and distribute these sample programs in
any form without payment to IBM, for the purposes of developing, using, marketing or distributing application
programs conforming to the application programming interface for the operating platform for which the sample
programs are written. These examples have not been thoroughly tested under all conditions. IBM, therefore,
cannot guarantee or imply reliability, serviceability, or function of these programs.
© Copyright International Business Machines Corporation 2009. All rights reserved.
Note to U.S. Government Users Restricted Rights -- Use, duplication or disclosure restricted by
GSA ADP Schedule Contract with IBM Corp.
35
This document REDP-4492-00 was created or updated on January 19, 2009.
Send us your comments in one of the following ways:
򐂰 Use the online Contact us review Redbooks form found at:
ibm.com/redbooks
򐂰 Send your comments in an email to:
redbooks@us.ibm.com
򐂰 Mail your comments to:
IBM Corporation, International Technical Support Organization
Dept. HYTD Mail Station P099
2455 South Road
Poughkeepsie, NY 12601-5400 U.S.A.
®
Redpaper ™
Trademarks
IBM, the IBM logo, and ibm.com are trademarks or registered trademarks of International Business Machines
Corporation in the United States, other countries, or both. These and other IBM trademarked terms are
marked on their first occurrence in this information with the appropriate symbol (® or ™), indicating US
registered or common law trademarks owned by IBM at the time this information was published. Such
trademarks may also be registered or common law trademarks in other countries. A current list of IBM
trademarks is available on the Web at http://www.ibm.com/legal/copytrade.shtml
The following terms are trademarks of the International Business Machines Corporation in the United States,
other countries, or both:
Domino®
IBM®
Redbooks (logo)
Tivoli®
®
The following terms are trademarks of other companies:
ITIL is a registered trademark, and a registered community trademark of the Office of Government
Commerce, and is registered in the U.S. Patent and Trademark Office.
Java, JavaScript, and all Java-based trademarks are trademarks of Sun Microsystems, Inc. in the United
States, other countries, or both.
Expression, Windows, and the Windows logo are trademarks of Microsoft Corporation in the United States,
other countries, or both.
Linux is a trademark of Linus Torvalds in the United States, other countries, or both.
Other company, product, or service names may be trademarks or service marks of others.
36
Creating IDML Discovery Books with IBM Tivoli Directory Integrator