Assuming that you already have a reference to the Config Instance object, you must obtain the MetamergeConfig object representing the configuration data structure for the whole Config Instance and then get the available AssemblyLines:
import com.ibm.di.config.interfaces.MetamergeConfig;
import com.ibm.di.config.interfaces.MetamergeFolder;
import com.ibm.di.config.interfaces.AssemblyLineConfig;
...
MetamergeConfig configuration = configInstance.getConfiguration();
MetamergeFolder configFolder =
configuration.getDefaultFolder(MetamergeConfig.ASSEMBLYLINE_FOLDER);
String[] assemblyLineNames = configFolder.getNames();
if (assemblyLineNames != null) {
for (int i=0; i<assemblyLineNames.length; i++) {
System.out.println(assemblyLineNames[i]);
// get the AssemblyLine configuration object
AssemblyLineConfig alConfig =
configuration.getAssemblyLine(assemblyLineNames[i]);
// do something with alConfig ...This block of code prints to the standard output the names of all AssemblyLines in the configuration and demonstrates how to get the AssemblyLine configuration objects. You can use the AssemblyLine configuration object to get more detailed information, such as which Connectors are configured in the AssemblyLine, their parameters, etc.
Note that the MetamergeConfig, MetamergeFolder and AssemblyLineConfig interfaces are not part of the Server API interfaces. They are part of the IBM® Security Directory Integrator configuration driver (see the import clauses in the example) and they are not remote objects. When configInstance.getConfiguration() is executed the MetamergeConfig object is serialized and transferred over the wire. Your code will then work with the local copy of that object.
You can get the active AssemblyLines either for a specific Config Instance or for all active AssemblyLines on the IBM Security Directory Integrator Server for all running Config Instances.
AssemblyLine[] assemblyLines = configInstance.getAssemblyLines();
for (int i=0; i
for (int i=0; i<assemblyLines.length; i++) {
System.out.println(assemblyLines[i].getName());
// do someting with assemblyLines[i]
}AssemblyLine[] assemblyLines = session.getAssemblyLines();
for (int i=0; i<assemblyLines.length; i++) {
System.out.println(assemblyLines[i].getName());
// do someting with assemblyLines[i]
// which Config Instance this AssemblyLine belongs to?
ConfigInstance alConfigInstance = assemblyLines[i].getConfigInstance();
}You can use the AssemblyLine Server API object to get various AssemblyLine properties, the AssemblyLine configuration object, AssemblyLine log, AssemblyLine result Entry as well as stop the AssemblyLine.
You can start an AssemblyLine through the Config Instance object to which the AssemblyLine belongs. You need to know the name of the AssemblyLine you want to start:
AssemblyLine assemblyLine = configInstance.startAssemblyLine("MyAssemblyLine");You also receive a reference to the newly started AssemblyLine instance.
The Server API provides a mechanism for manually running an AssemblyLine. In manual mode the AssemblyLine is not running in its own thread. Instead, when you start the AssemblyLine, it is only initialized. Iterations® on the AssemblyLine are done in a synchronous manner when the executeCycle() method of the AssemblyLine object is called. This call blocks the current thread and when the AssemblyLine iteration is done it returns the result Entry object.
The following code will start the TestAL AssemblyLine in manual mode and execute three iterations on it. The result Entry from each iteration is printed to the standard output:
AssemblyLineHandler alHandler = configInstance.startAssemblyLineManual("TestAL", null);
Entry entry = null;
for (int i=0; i<3; i++) {
entry = alh.executeCycle();
System.out.println("TestAL entry: " + entry);
}
alHandler.close();The startAssemblyLineManual(String aAssemblyLineName, Entry aInputData) method of the Config Instance object starts an AssemblyLine in manual mode and returns an object of type com.ibm.di.api.remote.AssemblyLineHandler. Through this object you can manually iterate through the AssemblyLine, you can pass an initial work Entry and various Task Call Block parameters, you can get a reference to the AssemblyLine Server API object and you can terminate the AssemblyLine when you are done with it.
You can imitate the AssemblyLine runtime behavior by calling executeCycle() until it returns NULL.
When you start an AssemblyLine through the Server API you can register a specific AssemblyLine listener that will receive notifications on each AssemblyLine iteration, delivering the result Entry, and also when the AssemblyLine terminates. Through this mechanism you can start an AssemblyLine from a remote application and easily receive all Entries produced by the AssemblyLine. The AssemblyLine listener will also deliver all messages logged during the execution of the AssemblyLine.
Your listener class must implement the com.ibm.di.api.remote.AssemblyLineListener interface (or com.ibm.di.api.local.AssemblyLineListener for local access).
The methods you must specify are:
A sample AssemblyLine listener class that only prints to the standard output all Entries received and all AssemblyLine log messages might look like this:
import com.ibm.di.api.DIException;
import com.ibm.di.api.remote.AssemblyLineListener;
import com.ibm.di.entry.Entry;
import java.rmi.RemoteException;
public class MyRemoteALListener implements AssemblyLineListener {
public void assemblyLineCycleDone(Entry aEntry)
throws DIException, RemoteException
{
System.out.println("AssemblyLine iteration: " + aEntry.toString());
System.out.println();
}
public void assemblyLineFinished()
throws DIException, RemoteException
{
System.out.println("AssemblyLine terminated.");
System.out.println();
}
public void messageLogged(String aMessage)
throws DIException, RemoteException
{
System.out.println("AssemblyLine log message: " + aMessage);
System.out.println();
}
}Once you have implemented your AssemblyLine listener class, you need to instantiate a listener object and pass it when starting the AssemblyLine:
MyRemoteALListener alListener = new MyRemoteALListener();
configInstance.startAssemblyLine("TestAL", null,
AssemblyLineListenerBase.createInstance(alListener,true), true);The startAssemblyLine(String aAssemblyLineName, Entry aInputData, AssemblyLineListener aListener, boolean aGetLogs) method specifies the name of the AssemblyLine, an initial work Entry, the listener object and whether you want to receive log messages - when aGetLogs is false, the messageLogged(String aMessage) listener method will not be called by the Server API.
When you are registering a listener in a remote context, you have to wrap your specific listener in an AssemblyLine Base Listener class - this is necessary to provide a bridge between your custom listener Java™ class that is not available on the Server side and the Server API notification mechanism. A base listener class is created by calling the static createInstance(AssemblyLineListener aListener, boolean aSSLon) method of the com.ibm.di.api.remote.impl.AssemblyLineListenerBase class. You need to provide the object representing your listener class and specify whether SSL is used for communication with the Server or not (you must specify how the Server API is configured on the Server side - otherwise the communication for that listener will fail).
By setting the simulation flag of an AssemblyLine to true you specify that the components behavior in the AssemblyLine will be simulated. The simulation functionality is described in more detail in IBM Security Directory Integrator Version 7.2 Users Guide; here we will only show how to set the simulation flag:
usertcb.setProperty(com.ibm.di.server.AssemblyLine.TCB_SIMULATE_MODE, Boolean.TRUE);Where "usertcb" is a TaskCallBlock object, and then start the AL using this object.
You need a reference to the AssemblyLine object in order to stop it. You can keep the reference to the AssemblyLine object from when you started the AssemblyLine or you can iterate through all running AssemblyLines and find the one you need. Execute the following line of code to stop the AssemblyLine:
assemblyLine.stop();