loggingservice.java

JADE实例——多Agent系统展示(图书交易系统)

package bookTrading.logging;

import jade.core.AID;
import jade.core.Agent;
import jade.core.BaseService;
import jade.core.Filter;
import jade.core.HorizontalCommand;
import jade.core.IMTPException;
import jade.core.Node;
import jade.core.Profile;
import jade.core.Service;
import jade.core.ServiceException;
import jade.core.ServiceHelper;
import jade.core.VerticalCommand;
import jade.core.messaging.GenericMessage;
import jade.core.messaging.MessagingSlice;
import jade.lang.acl.ACLMessage;

public class LoggingService extends BaseService {
	// Service name
	public static final String NAME =
		"bookTrading.logging.Logging";
	// Service parameter names
	public static final String VERBOSE =
		"bookTrading_logging_LoggingService_verbose";
	
	private boolean verbose = false;
	
	private Filter outFilter = new OutgoingLoggingFilter();
	
	private Service.Slice localSlice = new LoggingSliceImpl();
	
	private ServiceHelper helper = new LoggingHelperImpl();
	
	public String getName() {
		return NAME;
	}
	
	public void boot(Profile p) throws ServiceException {
		super.boot(p);
		verbose = p.getBooleanProperty(VERBOSE, false);
		System.out.println("VERBOSE = " + verbose);
	}
	
	public Filter getCommandFilter(boolean direction) {
		if (direction == Filter.OUTGOING) {
			return outFilter;
		}
		else {
			return null;
		}
	}
	
	public Class getHorizontalInterface() {
		return LoggingSlice.class;
	}
	
	public Service.Slice getLocalSlice() {
		return localSlice;
	}
	
	public ServiceHelper getHelper (Agent a) {
		return helper;
	}
	
	private class OutgoingLoggingFilter extends Filter {
		public boolean accept (VerticalCommand cmd) {
			if (cmd.getName().equals(MessagingSlice.SEND_MESSAGE)) {
				Object[] params = cmd.getParams();
				AID sender = (AID)params[0];
				GenericMessage gMsg = (GenericMessage)params[1];
				ACLMessage msg = gMsg.getACLMessage();
				AID receiver = (AID)params[2];
				// Prepare the log record
				String logRecord = "Message from " + sender
					+ " to " + receiver + ":";
				if(verbose) {
					logRecord += msg;					
				}
				else {
					logRecord += ACLMessage.getPerformative(
							msg.getPerformative());
				}
				
				// Send the log record to the logging slice on the Main Container
				try {
					LoggingSlice mainSlice =
						(LoggingSlice)getSlice(MAIN_SLICE);
					mainSlice.logMessage(logRecord);
				}
				catch (ServiceException se) {
					System.out.println("Error retrieving Main Logging Slice");
					se.printStackTrace();
				}
				catch (IMTPException impte) {
					System.out.println ("Error contacting Main Logging Slice");
					impte.printStackTrace();
				}
			}
			// Never block a command
			return true;
		}
	}
	
	private class LoggingSliceImpl implements Service.Slice {
		public Service getService() {
			return LoggingService.this;
		}
		
		public Node getNode() throws ServiceException {
			try {
				return LoggingService.this.getLocalNode();
			}
			catch(IMTPException impte) {
				// Should never happen as this is a local call
				throw new ServiceException(
						"Unexpected error retrieving local node");
			}
		}
		
		public VerticalCommand serve(HorizontalCommand cmd) {
			String cmdName = cmd.getName();
			if (cmdName.equals(LoggingSlice.H_LOGMESSAGE)) {
				Object[] params = cmd.getParams();
				System.out.println(params[0]);
			}
			
			return null;
		}
	}
	
	public class LoggingHelperImpl implements LoggingHelper {
		public void init(Agent a) {			
		}
		
		public void setVerbose (boolean v) {
			verbose = v;
		}
	}
}