Listeners and Listener Notifications

The ADK includes both, synchronous and asynchronous processing model.

The implementation of a listener and listener notification is similar to the implementation of an adapter connection. Each implementation includes a Java class extending an ADK base class, and a namespace node in which design-time configuration data is stored. In the Java class, the metadata model for listeners and listener notification is nearly identical to that of adapter connections. The configuration pages are built from the listeners metadata. For more information, see Metadata Model for Connection

package com.wm.MyAdapter.listeners;

import com.wm.adk.error.AdapterException;
import com.wm.adk.metadata.WmDescriptor;
import com.wm.adk.notification.WmConnectedListener;
import com.wm.adk.notification.NotificationResults;

import java.io.FileReader;
import java.util.Locale;
import javax.resource.ResourceException;

import com.wm.MyAdapter.MyAdapter;
import com.wm.MyAdapter.connections.SimpleConnection;

public class SimpleListener extends WmConnectedListener 
{
	public static final String FILE_NAME_PARM = "fileName";
	private String _fileName = null;
	public void setFileName(String val){_fileName = val;}

	private FileReader _reader = null;  
	private StringBuffer workingBuffer = new StringBuffer();  
	private String _lastDataObject = null;

	public void fillWmDescriptor(WmDescriptor descriptor, Locale locale)
		throws ResourceException
	{
		descriptor.setRequired(FILE_NAME_PARM);
		descriptor.setDescriptions(
			MyAdapter.getInstance().getAdapterResourceBundleManager(), locale);
	}

	public void listenerStartup() throws ResourceException  
	{
		try  
		{  
			//_reader = ((SimpleConnection)retrieveConnection()).getReader();  
			_reader = ((SimpleConnection)retrieveConnection()).getReader(_fileName);
			while(_reader.ready())  
			{  
				_reader.read();  // move to the end of the stream  
			}  
		}  
		catch (Throwable t)  
		{  
			throw MyAdapter.getInstance().createAdapterException(100,t);  
		}  
	}

	public Object waitForData() throws ResourceException  
	{  
		try  
		{  
			if(_reader.ready())  
			{  
				do  
				{  
					int i = _reader.read();  
					if (i != -1)  
					{  
						char c = (char)i;  
						workingBuffer.append(c);  
						if(c == '\n')  
						{  
							_lastDataObject = new String(workingBuffer);  
							workingBuffer = new StringBuffer();  
							break;  
						}
					}  
					else  
					{  
						break;  
					}  
				} while (_reader.ready());
			}
		}
		catch (Throwable t)  
		{  
			throw MyAdapter.getInstance().createAdapterException(100,t);  
		}  
		return _lastDataObject;  
	}

public void listenerShutdown()  
	{  
		try  
		{  
			_reader.close();  
		}  
		catch(Throwable t){}  
	}
	public void processNotificationResults(NotificationResults results)  
		throws ResourceException  
	{  
		if(results != null)  
		{  
			if(results.hadError())  
			{  
				MyAdapter.getLogger().logError(9999,  
					"Error processing: " + this._lastDataObject + 
					" errorInfo = " + (results.getErrorInfo() == null ? "" : results.getErrorInfo().toString()));  
			}  
		}  
		else  
		{  
			MyAdapter.getLogger().logError( 9999, 
				"No notification available to process:" + 
				this._lastDataObject);  
		}  
	}
}

The next step for implementing a listener is to create the metadata constructs that the users of the adapter use for entering data when they create listener notification nodes. To do this, perform the following:

• Create metadata parameters appropriate for the function of the listener notification nodes. Each parameter has:
  • A variable to hold the configured values.
  • A String constant containing the name of the parameter.
  • An accessor method.
  • A set of resource bundle entries with a localizable parameter name and description as shown in Updating the Resource Bundle.

  For more information on metadata parameters, see Metadata Model for Connection.

• Describe presentation for those metadata parameters.
• Set the data entry rules for those metadata parameters.

The example implementation includes one metadata parameter, that the users of the adapter use to create listener notification nodes. The following table describes the purpose of each of these parameters for data entry:

public class SimpleListener extends WmConnectedListener  
{  
...  
   public String[] restrictNotificationTypes()  
   {  
      return new String[]{"com.wm.myadapter.notifications.FooNotification",  
                          "com.wm.myadapter.notifications.BarNotification"};  
   }  
...  
}

The example also includes an implementation of processNotificationResults.

Update the resource bundle with a display name, and description to make the listener more usable. For example:

package com.wm.MyAdapter;
..
..
import com.wm.MyAdapter.listeners.SimpleListener;
..
..
public class MyAdapterResource extends ListResourceBundle implements MyAdapterConstants{
   ..
   .. 
 static final Object[][] _contents = {	
   ..
   .. 	
		//Listener 
		,{SimpleListener.class.getName() + ADKGLOBAL.RESOURCEBUNDLEKEY_DISPLAYNAME,
			"Simple Listener"}
		,{SimpleListener.class.getName() + ADKGLOBAL.RESOURCEBUNDLEKEY_DESCRIPTION,
			"Use to monitor log files"}
		,{SimpleListener.FILE_NAME_PARM + ADKGLOBAL.RESOURCEBUNDLEKEY_DISPLAYNAME,
			"Log File Name"}

  }
  protected Object[][] getContents() {
		 // TODO Auto-generated method stub
		 return _contents;
  }
}

You must register each listener class in the WmAdapter implementation class. You do this by passing the class name to the AdapterTypeInfo.addListenerType method in the WmAdapter.fillAdapterTypeInfo method in the WmAdapter implementation class. In the example, the listener class SimpleListener is registered in the adapter implementation class MyAdapter:

package com.wm.MyAdapter;
..
..
import com.wm.MyAdapter.listeners.SimpleListener;  
..
..  
public class MyAdapter extends WmAdapter implements MyAdapterConstants {
..
.. 
	public void fillAdapterTypeInfo(AdapterTypeInfo info, Locale locale)  
	{
    ..
    ..
    info.addListenerType(SimpleListener.class.getName());  
 }
}

package com.wm.MyAdapter.listeners;

import com.wm.adk.error.AdapterException;
import com.wm.adk.metadata.WmDescriptor;
import com.wm.adk.notification.WmAsyncListenerNotification;
import com.wm.adk.notification.NotificationResults;
import com.wm.adk.notification.AsyncNotificationResults;
import com.wm.adk.notification.NotificationEvent;
import com.wm.adk.connection.WmManagedConnection;
import com.wm.adk.metadata.*;
import com.wm.adk.cci.record.WmRecord;
import com.wm.adk.cci.record.WmRecordFactory;

import javax.resource.ResourceException;
import java.util.Locale;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.StringTokenizer;

import com.wm.MyAdapter.MyAdapter;
import com.wm.MyAdapter.MyAdapterConstants;
import com.wm.MyAdapter.connections.SimpleConnection;

public class SessionLogListenerNotification extends WmAsyncListenerNotification
	implements MyAdapterConstants
{

	private String[] _fieldNames = null;
	private String[] _fieldTypes = null;
	private boolean[] _uses = null;

	public void setFieldNames(String[] val){_fieldNames = val;}
	public void setFieldTypes(String[] val){_fieldTypes = val;}
	public void setUses (boolean[] val){_uses = val;}
	public void setSignature(String[] val){}

	public static final String NOTIFICATION_SETUP_GROUP =
	"SessionLogListenerNotification.setup";

	public static final String FIELD_NAMES_PARM = "fieldNames";
	public static final String FIELD_TYPES_PARM = "fieldTypes";
	public static final String USES_PARM = "uses";
	public static final String SIG_PARM = "signature";

	public static final String FIELD_NAMES_RD =	
		"SessionLogListenerNotification.fieldNames.rd";
	public static final String FIELD_TYPES_RD = 
		"SessionLogListenerNotification.fieldTypes.rd";

	public static final String[] _sigFieldNames = {
		"timeStamp",
		"component",
		"rootContext",
		"parentContext",
		"currentContext",
		"server",
		"eventCode",
		"user",
		"sessionName",
		"RPCs",
		"age"};
	private Object[] _parsedValues = new Object[_sigFieldNames.length];

public void fillWmTemplateDescriptor(WmTemplateDescriptor descriptor,Locale l)
		throws ResourceException
	{
		String[] parms = new String[] {FIELD_NAMES_PARM,
			FIELD_TYPES_PARM,
			USES_PARM,
			SIG_PARM};
		descriptor.createGroup(NOTIFICATION_SETUP_GROUP, parms);
		descriptor.createFieldMap(parms, false);
		descriptor.createTuple(new String[]{FIELD_NAMES_PARM, FIELD_TYPES_PARM});

		descriptor.setResourceDomain(FIELD_NAMES_PARM, FIELD_NAMES_RD, null);
		descriptor.setResourceDomain(FIELD_TYPES_PARM, FIELD_TYPES_RD, null);
		descriptor.setResourceDomain(SIG_PARM, 
			WmTemplateDescriptor.OUTPUT_FIELD_NAMES,new String[]{
				FIELD_NAMES_PARM,FIELD_TYPES_PARM}, USES_PARM);

		descriptor.setDescriptions( MyAdapter.getInstance().
			getAdapterResourceBundleManager(), l);
	}

	public Boolean adapterCheckValue(WmManagedConnection connection,
		String resourceDomainName, String[][] values, 
		String testValue) throws AdapterException
	{
		return true;
	}
	public ResourceDomainValues[] adapterResourceDomainLookup(
		WmManagedConnection connection, String resourceDomainName,
		String[][] values) throws AdapterException
	{
		ResourceDomainValues[] results = null;
		if (resourceDomainName.equals(FIELD_NAMES_RD)
			|| resourceDomainName.equals(FIELD_TYPES_RD))
		{
			ResourceDomainValues names = new ResourceDomainValues(
				FIELD_NAMES_RD, _sigFieldNames);
			ResourceDomainValues types = new ResourceDomainValues(
				FIELD_TYPES_RD,new String[] {
					Date.class.getName(), //timestamp
					String.class.getName(), // component
					String.class.getName(), // rootContext
					String.class.getName(), // parentContext
					String.class.getName(), // currentContext
					String.class.getName(), // server
					Integer.class.getName(), // eventCode
					String.class.getName(), // user
					String.class.getName(), // sessionName
					Integer.class.getName(), // RPCs
					Long.class.getName() // age
				});
			results = new ResourceDomainValues[] {names,types};
		}
		return results;
	}
	public void registerResourceDomain(WmManagedConnection connection,
		WmAdapterAccess access) throws AdapterException
	{
		access.addResourceDomainLookup(this.getClass().getName(), 
			FIELD_NAMES_RD, connection);
		access.addResourceDomainLookup(this.getClass().getName(), 
			FIELD_TYPES_RD, connection);
	}

	public boolean supports(Object data) throws ResourceException
	{
		boolean result = false;
		try
		{
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd H:mm:ss zzz");
			String sData = (String)data;
			this._parsedValues[0] = sdf.parse(sData.substring(0,48));
			StringTokenizer st = new StringTokenizer(sData.substring(49)," ",false);
			this._parsedValues[1] = st.nextToken();
			this._parsedValues[2] = st.nextToken();
			this._parsedValues[3] = st.nextToken();
			this._parsedValues[4] = st.nextToken();
			/*
			st.nextToken(); // skip the session ID
			this._parsedValues[5] = st.nextToken();
			this._parsedValues[6] = new Integer(st.nextToken());
			this._parsedValues[7] = st.nextToken();
			this._parsedValues[8] = st.nextToken();
			this._parsedValues[9] = new Integer(st.nextToken());
			this._parsedValues[10] = new Long(st.nextToken());
			*/
			result = true;
		}
		catch(Throwable t){}
		return result;
	}
	
	public NotificationResults runNotification(NotificationEvent event)
		throws ResourceException
	{
		NotificationResults result = null;
		WmRecord notice = WmRecordFactory.getFactory().createWmRecord("notUsed");
		for(int i = 0; i< _sigFieldNames.length;i++)
		{
			if (_uses[i])
			{
				notice.put(_sigFieldNames[i],_parsedValues[i]);
			}
		}
		this.doNotify(notice);
		result = new AsyncNotificationResults(this.nodeName(),true,null);
		return result;

	}
}

The example listener notification in this section includes only those configuration parameters that are directly related to the signature. The only new concept in this section is the use of the useParam argument of theWmTemplateDescriptor.setResourceDomain method.

This example implementation of the supports method parses the contents of the data object that is originally returned from the listener's waitForData method, into the _parsedValues object variable. Any error in the parsing process indicates that the data object was not a session log entry, and the supports method returns a false value.

The runNotification method implementation assumes that the supports method was successful in parsing the data object, so it does not need the NotificationEvent argument. It merely populates a WmRecord object by inserting the parsed names, using the same key names array that populate the resource domain.

Update the resource bundle with a display name, and description to make the listener notification more usable.

package com.wm.MyAdapter;
..
..
import com.wm.MyAdapter.listeners.SessionLogListenerNotification;
..
..
public class MyAdapterResource extends ListResourceBundle implements MyAdapterConstants{
   ..
   .. 
 static final Object[][] _contents = {	
   ..
   .. 	
  //SessionLog Listener Notification
		,{SessionLogListenerNotification.class.getName() + ADKGLOBAL.RESOURCEBUNDLEKEY_DISPLAYNAME,
			"SessionLog Listener Notification"}
		,{SessionLogListenerNotification.class.getName() + ADKGLOBAL.RESOURCEBUNDLEKEY_DESCRIPTION,
			"Use SessionLog Listener Notification to monitor log files"}
		,{SessionLogListenerNotification.FIELD_NAMES_PARM + ADKGLOBAL.RESOURCEBUNDLEKEY_DISPLAYNAME,
			"Field Name"}
		,{SessionLogListenerNotification.FIELD_NAMES_PARM + ADKGLOBAL.RESOURCEBUNDLEKEY_DESCRIPTION,
			"Field Name To Check"}
		,{SessionLogListenerNotification.FIELD_TYPES_PARM + ADKGLOBAL.RESOURCEBUNDLEKEY_DISPLAYNAME,
			"Field Types"}
		,{SessionLogListenerNotification.FIELD_TYPES_PARM + ADKGLOBAL.RESOURCEBUNDLEKEY_DESCRIPTION,
			"Field Types To Check"}

  }
  protected Object[][] getContents() {
		 // TODO Auto-generated method stub
		 return _contents;
  }
}

You must register each listener notification class in the WmAdapter implementation class. You do this by passing the class name to the AdapterTypeInfo.addNotificationType method in the WmAdapter.fillAdapterTypeInfo method in the WmAdapter implementation class. In the example, the listener notification class SessionLogListenerNotification is registered in the adapter implementation class MyAdapter:

For example:

package com.wm.MyAdapter;
..
..
import com.wm.MyAdapter.listeners.SessionLogListenerNotification;  
..
..  
public class MyAdapter extends WmAdapter implements MyAdapterConstants {
..
.. 
	public void fillAdapterTypeInfo(AdapterTypeInfo info, Locale locale)  
	{
    ..
    ..
    info.addNotificationType(SessionLogListenerNotification.class.getName());  
 }
}

Now you are ready to configure a listener notification node as follows:

• Configuring Listener Notification Nodes
• Testing Listener Nodes and Listener Notification Nodes