About this task
This task instructs you to stop and restart integration
nodes. This action is required in all but the two circumstances
described in step 4 later
in this section, although if you do stop and restart the integration
node, you can ensure that anyone with an interest in a particular
integration server is made aware that recent changes have been
made.
This task is applicable to user-defined
nodes written in Java or C only. If your user-defined node contains a custom compiler,
you must install the compiled runtime files and the user-defined node
plug-in to the integration node. If your user-defined node does not
contain a custom compiler, install only the compiled runtime files
to the integration node.
To install runtime and
user-defined node plug-in files on the integration node:
- Stop the integration node on which you want to install
your compiled or packaged user-defined extension file (files with
extension .lil, .jar, .par, .pdb,
or .lel)
- Create a directory if you do not already have one for this
purpose. Add the directory to the LILPATH by using the mqsichangebroker command.
CAUTION:
Do not put the .lil, .jar, .par, .pdb,
or .lel files in the WebSphere® IBM Integration installation directory,
because they might be overwritten by the integration node.
- Put your user-defined file in the directory, and make sure
that the integration node has access to it. For example,
on Linux or UNIX, use the chmod 755* command
on the file. If your user-defined node contains a custom
compiler, put your user-defined plug-in file in the same directory.
- Stop and restart the integration node
to implement the change and to ensure that the existence of the new
file is detected. An integration node restart is not necessary
in the following circumstances:
- If you have created an integration server in the IBM Integration Toolkit, and nothing is yet deployed
to it, you can add the .lil, .pdb, .jar, .par,
or .lel file to your selected directory.
- If something has already been deployed to the integration server
that you want to use, add the .lil, .pdb, .jar, .par,
or .lel file to your selected directory, and
issue the mqsireload command
to restart the group. You cannot overwrite an existing file on the Windows system when the integration
node is running, because of the file lock that is put in place by
the operating system.
Use these two approaches with care, because any integration
server that is connected to the same integration node also detects
the new .lil, .pdb, .jar, .par,
or .lel files when that integration server restarts,
or when something is first deployed to that integration server.
- Repeat the previous steps for every integration node that
needs the user-defined extension file and user-defined node
plug-in file. If all of your integration nodes are on the
same operating system type, you can build the user-defined extension
file once and distribute it to each of your systems.
If
you have a cluster, for example, that includes one AIX®, one Solaris,
and one Windows integration
node, you must build the user-defined extension files separately
on each operating system type.
On Windows,
the .pdb file provides symbolic information
that is used when stack diagnostic information is displayed
in the event of access violations or other software malfunctions.
- For C user-defined extensions, store the .pdb file
in the same directory as the .lil file to which
it corresponds.
- Use either the mqsichangebroker command or
the mqsicreatebroker command,
as appropriate, to specify to the integration node the directory that
contains the user-defined extension file.
When you have
installed a user-defined extension, it is referred to by its schema
and name, just like a message flow.
Results
The integration node loads the user-defined
extension files during initialization. After loading the files, the
integration node calls the registration functions in the user-defined
extension and records what nodes or parsers the user-defined extension
supports.
A C user-defined
extension implements a node or parser factory that can support multiple
nodes or parser types. For more information, see Node and parser factory behavior. Java users
are not required to write a node factory.