WebSVN – HomeAutomation – Diff – /trunk/MacBeth/src/Macbeth/System/MbKernel.java


/**
 * File created by Jimmy
 * at 2003-dec-25 16:15:54
 */
package Macbeth.System;
 
import Macbeth.Utilities.*;
import Macbeth.XML.XMLDataHandler;
import Macbeth.XML.XMLParser;
import Macbeth.Transports.MbLocalTransport;
import Macbeth.Transports.MbInternetTransport;
 
import java.io.*;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.HashMap;
import java.util.List;
 
import org.xml.sax.SAXException;
 
/**
 * The Macbeth kernel. This is the core component that does all the
 * work. You need to extend this class in order to create command-line
 * kernels, GUI-kernels or whatever else.
 * @author Jimmy
 */
public abstract class MbKernel extends MbComponent {
 
    //list of all existing modules (module names mapped to module class names)
    protected HashMap moduleList;
    //list of loaded modules (module names mapped to module objects)
    protected HashMap loadedModules;
    //our debug-output-stream (write meaningless debug-info here)
    protected PrintStream _debug;
    //our info-output-stream (write important info here)
    protected PrintStream _info;
    //our error-output-stream (write error messages here)
    protected PrintStream _errors;
    //our logfile-stream
    protected PrintStream _log;
    //a null-stream that ignores any data written to it
    protected PrintStream _null;
    //list of packet transports
    protected List packetTransports;
    //default transports
    protected MbLocalTransport localTransport;
    protected MbInternetTransport internetTransport;
    //packet dumper
    protected PacketDumper packetDumper;
    //our kernel configuration XML-file
    protected String configFile;
    //our data repository. stores options and other data from the XML-file
    protected DataRepository dataRepository;
    //this points to the options data entry inside the data repository
    protected DataRepository.DataListItem options;
    //in this map, all used script events are mapped to lists filled with MbActions
    protected HashMap scriptEventActions;
 
    /**
     * Creates a new instance of MbKernel.
     * @param configFile The XML-configuration file to use for this kernel.
     */
    public MbKernel(String configFile) {
        //construct MbComponent
        super();
 
        //remember configuration file
        this.configFile = configFile;
 
        //create data repository
        dataRepository = new DataRepository();
        dataRepository.advancedBuild_BeginList("options");
        dataRepository.advancedBuild_BeginListItem();
        dataRepository.advancedBuild_EndListItem();
        dataRepository.advancedBuild_EndList();
        options = (DataRepository.DataListItem)dataRepository.getList("options").firstItem();
 
        //set default values on all our options
        options.putField("kernelname", "Macbeth@" + System.getProperty("user.name").toString());
        //options.putField("moduledirectory", System.getProperty("user.dir") + "\\bin\\");
        options.putField("moduledirectory", System.getProperty("user.dir") + File.separator+"bin"+File.separator);
        options.putField("debugstream.logged", "false");
        options.putField("debugstream.timestamped", "false");
        options.putField("debugstream.visible", "false");
        options.putField("debugstream.prefix", "D ");
        options.putField("infostream.logged", "false");
        options.putField("infostream.timestamped", "true");
        options.putField("infostream.visible", "true");
        options.putField("infostream.prefix", "I ");
        options.putField("errorstream.logged", "false");
        options.putField("errorstream.timestamped", "true");
        options.putField("errorstream.visible", "true");
        options.putField("errorstream.prefix", "E ");
 
        //create output streams
        _debug = System.out;
        _info = System.out;
        _errors = System.err;
 
        //log stream will be created during startup
        _log = null;
 
        //create null stream
        _null = new PrintStream(new PipedOutputStream());
 
        //create module lists
        moduleList = new HashMap(32);
        loadedModules = new HashMap(32);
 
        //create packet transport list
        packetTransports = new LinkedList();
        //TODO: search dynamically for installed transports at runtime instead.
        //add local delivery transport
        localTransport = new MbLocalTransport(this);
        installTransport(localTransport);
        //add internet delivery transport
        internetTransport = new MbInternetTransport(this);
        installTransport(internetTransport);
 
        //create packet dumper
        packetDumper = new PacketDumper();
 
        //create the script map
        scriptEventActions = new HashMap();
    }
 
    /**
     * Installs a packet delivery transport into this kernel.
     * @param t The transport.
     */
    protected void installTransport(MbPacketTransport t) {
        packetTransports.add(t);
    }
 
    /**
     * Gets the name of this kernel. Per default, this is
     * "Macbeth@username" where username is your computer
     * username.
     * @return The kernel name.
     */
    public String name() {
        return (String)options.getField("kernelname");
    }
 
    /**
     * Gets a short description of the kernel. This should
     * be kept short (1-2 lines) and should be formatted as
     * plain text.
     * @return A short description of the kernel.
     */
    public abstract String description();
 
 
    /**
     * Call this when you want to trigger events from the kernel. Note that
     * the event name you provide will automatically be prefixed by the string
     * "Kernel.On" so that the final event string takes the form
     * 'Kernel.OnXXX" where XXX is the event name you provide.
     *
     * @param eventName The name of the event. Please read above.
     */
    private final void triggerEvent(String eventName) {
        triggerMacbethEvent("Kernel.On" + eventName);
    }
 
 
    /**
     * Triggers a Macbeth event. The kernel will perform all Macbeth
     * actions that are associated with this event.
     *
     * @param eventName The name of the Macbeth event that is being triggered.
     */
    public void triggerMacbethEvent(String eventName) {
        //get all actions associated with this event
        List l = (List) scriptEventActions.get(eventName);
        if (l!=null) {
            Iterator it = l.iterator();
            while (it.hasNext()) {
                MbAction a = (MbAction) it.next();
                try {
                    performAction(a);
                } catch (MbActionNotPerformedException e) {
                    _errors.println("The scripted action '" + a.getActionString() + " " + a.getParameters() + "' could not be performed! (" + e.getMessage() + ")");
                }
            }
        }
    }
 
 
    /**
     * Performs an action (called by scripts or by the user).
     * @param action The Macbeth action that should be performed.
     * @throws MbActionNotPerformedException If, for some reason, this action could not be performed.
     */
    protected void performAction(MbAction action) throws MbActionNotPerformedException {
        //split the action string into owner and action name
        String[] tokens = action.getActionString().split("\\.");
        if (tokens.length!=2) {
            throw new MbActionNotPerformedException("Invalid action string (format should be OWNER.ACTION)");
        }
        //extract owner
        String owner = tokens[0];
        String actionName = tokens[1];
 
        //if the action was owned by us (that is by the kernel), let's perform it
        if (owner.equalsIgnoreCase("Kernel")) {
            if (actionName.equalsIgnoreCase("LoadModule")) {
                try {
                    loadModule(action.getParameters());
                } catch (MbModuleNotFoundException e) {
                    throw new MbActionNotPerformedException("Module not found!");
                } catch (MbModuleLoadException e) {
                    throw new MbActionNotPerformedException("Module found, but couldn't be loaded!");
                }
            }
            else if (actionName.equalsIgnoreCase("UnloadModule")) {
                if (!unloadModule(action.getParameters())) {
                    throw new MbActionNotPerformedException("Module not loaded!");
                }
            }
            //TODO: action that can clean up the packet queue with some filtering abilities
            //TODO: action that reloads all modules
            else {
                throw new MbActionNotPerformedException("Unknown kernel action!");
            }
        }
        //the action isn't owned by the kernel, so it must be owned by a module
        else {
            //try to get the owner module
            MbModule m = (MbModule) loadedModules.get(owner);
            //check if it existed
            if (m==null) {
                throw new MbActionNotPerformedException("The module '" + owner + "' isn't loaded!");
            }
            //handle over the action to the module
            m.performAction(action);
        }
    }
 
    /**
     * Starts up this kernel.
     */
    public void startup() throws MbStartupException {
        _debug.println("Macbeth kernel is starting up");
        //start up MbComponent
        super.startup();
 
        //create XML parser and parse configuration file
        _debug.println("Parsing kernel configuration file: " + configFile);
        XMLParser xmlParser = new XMLParser(new ConfigDataHandler());
        try {
            xmlParser.parseFile(configFile);
        } catch (FileNotFoundException e) {
            _errors.println("Configuration file '" + configFile + "' not found. Default settings will be used!");
        } catch (IOException e) {
            _errors.println("I/O error while reading '" + configFile + "'. Default settings will be used!");
        } catch (SAXException e) {
            _errors.println("XML Parsing error while reading '" + configFile + "'. Settings might have been lost. Please check syntax!");
        }
        _debug.println("Finished parsing kernel configuration file");
 
        //start up packet transport systems
        _debug.println("Starting up packet transport systems:");
        Iterator it = packetTransports.iterator();
        while (it.hasNext()) {
            MbPacketTransport pt = (MbPacketTransport)it.next();
            if (pt!=null) {
                _debug.println("  - " + pt.getName());
                pt.startup();
            }
        }
        _debug.println("OK, " + packetTransports.size() + " transports installed");
 
        //create a module list
        _debug.println("Enumerating modules...");
        LinkedList classList = new LinkedList();
        try {
            //_debug.println("moduledirectory: " + options.getField("moduledirectory"));
            //try to load all classes that inherit from Macbeth.Systen.MbModule, since these are all modules
            DynamicClassLoader.locateClasses(options.getField("moduledirectory"), "", new String[]{"Macbeth.System.MbModule"}, null, classList);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        //iterate through the class list to find out the module names
        it = classList.iterator();
        while (it.hasNext()) {
            String classname = (String)it.next();
            try {
                Class c = DynamicClassLoader.loadClass(options.getField("moduledirectory"), classname);
                //construct a new module (so we can get its name)
                MbModule mod = (MbModule)c.newInstance();
                //save the module name mapped to the full classname in module list
                moduleList.put(mod.name(),classname);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        _debug.println("OK, " + Integer.toString(classList.size()) + " modules found");
 
        _debug.println("Setting up streams (visibility, timestamping, logging)...");
 
        //create logstreams (that might be needed if logging is enabled)
        String logfile = "Macbeth log " + MyDateTime.now("yyyy-MM-dd HH_mm_ss") + ".log";
 
        //if any logging is enabled
        if (options.getField("debugstream.logged").equalsIgnoreCase("true") ||
            options.getField("infostream.logged").equalsIgnoreCase("true") ||
            options.getField("errorstream.logged").equalsIgnoreCase("true")) {
            //create log stream
            try {
                _log = new PrintStream(new FileOutputStream(logfile));
            } catch (FileNotFoundException e) {
                //the log stream has to be valid in order to proceed
                throw new MbStartupException("Error while trying to create the log file '" + logfile + "'!");
            }
        }
 
        //if visibility is turned off for any of the streams, redirect them to null stream
        if (options.getField("debugstream.visible").equalsIgnoreCase("false")) {
            _debug = _null;
        }
        if (options.getField("infostream.visible").equalsIgnoreCase("false")) {
            _info = _null;
        }
        if (options.getField("errorstream.visible").equalsIgnoreCase("false")) {
            _errors = _null;
        }
 
        //add logging to the streams
        if (options.getField("debugstream.logged").equalsIgnoreCase("true")) {
            _debug = new MultipleStreamsAdapter(_debug, _log);
        }
        if (options.getField("infostream.logged").equalsIgnoreCase("true")) {
            _info = new MultipleStreamsAdapter(_info, _log);
        }
        if (options.getField("errorstream.logged").equalsIgnoreCase("true")) {
            _errors = new MultipleStreamsAdapter(_errors, _log);
        }
 
        //add prefixes to streams
        _debug = new TextFormatterStream(_debug);
        ((TextFormatterStream) _debug).setPreString(options.getField("debugstream.prefix"));
        _info = new TextFormatterStream(_info);
        ((TextFormatterStream) _info).setPreString(options.getField("infostream.prefix"));
        _errors = new TextFormatterStream(_errors);
        ((TextFormatterStream) _errors).setPreString(options.getField("errorstream.prefix"));
 
        //add timestamps to streams
        if (options.getField("debugstream.timestamped").equalsIgnoreCase("true")) {
            _debug = new TimeStampedStream(_debug);
        }
        if (options.getField("infostream.timestamped").equalsIgnoreCase("true")) {
            _info = new TimeStampedStream(_info);
        }
        if (options.getField("errorstream.timestamped").equalsIgnoreCase("true")) {
            _errors = new TimeStampedStream(_errors);
        }
 
        //trigger the Startup-event now so any scripted post-processing can take place
        triggerEvent("Startup");
 
        //everything is started up now
        _info.println("Macbeth kernel started!");
    }
 
    /**
     * Loads and starts up a specific module. Before any modules
     * can be loaded, the module list must have been created. The
     * kernel will do this during startup, so normally this is not
     * a problem.
     * @param moduleName The name of the module that should be loaded.
     * @return true if this module was loaded and started successfully,
     * false if not (because the module was already started!).
     * @throws MbModuleNotFoundException if the specified module isn't found.
     * @throws MbModuleLoadException if the module cannot be loaded and started.
     */
    protected boolean loadModule(String moduleName) throws MbModuleNotFoundException, MbModuleLoadException {
        //if module is already loaded
        if (loadedModules.containsKey(moduleName)) {
            //get out of here
            return false;
        }
        //get classname from our module list
        String classname = (String)moduleList.get(moduleName);
        //if it was in the list
        if (classname!=null) {
            Class c;
            MbModule mod;
            try {
                //try to load class
                c = DynamicClassLoader.loadClass(options.getField("moduledirectory"),classname);
                //try to create new instance (and thus, constuct the module)
                mod = (MbModule)c.newInstance();
            } catch (Exception e) {
                //module couldn't be loaded
                throw new MbModuleLoadException(e.getMessage());
            }
            //work out dependencies for this module
            List dependencies = mod.getDependencies();
            //if there are dependencies
            if (!dependencies.isEmpty()) {
                //for each dependency
                Iterator it = dependencies.iterator();
                while (it.hasNext()) {
                    String dpmod = (String)it.next();
                    if (!loadedModules.containsKey(dpmod)) {
                        _info.println("'" + mod.name() + "' depends on '" + dpmod + "'. This module will now be loaded as well!");
                        loadModule(dpmod);
                    }
                }
            }
            //try to start up module now
            mod.setParentKernel(this);
            try {
                mod.startup();
                //put module in our loaded modules-list
                loadedModules.put(mod.name(), mod);
            }
            //if module failed to start up
            catch (MbStartupException e) {
                _errors.println("Module '" + mod.name() + "' failed to load! (" + e.getMessage() + ")");
                //shut down the parts of the module that were started up
                mod.shutdown();
                //and throw exception
                throw new MbModuleLoadException(e.getMessage());
            }
        }
        //module wasn't found
        else {
            //so throw exception
            throw new MbModuleNotFoundException("Module not found in module list!");
        }
        return true;
    }
 
    /**
     * Shuts down and unloads a specific module.
     * @param moduleName The name of the module that should be unloaded.
     * @return true if the module was shut down, false if not (because
     * it wasn't even started in the first place!).
     */
    protected boolean unloadModule(String moduleName) {
        //get the module from the enumeration list
        MbModule mod = (MbModule)loadedModules.get(moduleName);
        //if module was found (and thus, loaded)
        if (mod != null) {
            //shut it down
            mod.shutdown();
            loadedModules.remove(moduleName);
        }
        //module wasn't started
        else {
            return false;
        }
        return true;
    }
 
    /**
     * Returns a given macbeth module. The module must be loaded
     * in this local kernel, or else an exception will be thrown.
     * @param moduleName Classname of the module.
     * @return The module. Null if it isn't found (that is, not loaded).
     * be found within this kernel.
     */
    public MbModule getModule(String moduleName) {
        return (MbModule)loadedModules.get(moduleName);
    }
 
    /**
     * Shuts down this kernel. Modules will be shut
     * down and removed from module collection.
     */
    public void shutdown() {
        _debug.println("Macbeth kernel is about to shut down");
 
        //trigger shutdown-event first so any scripted pre-processing can take place
        triggerEvent("Shutdown");
 
        //shut down any loaded modules
        if (!loadedModules.isEmpty()) {
            _debug.println("Shutting down started modules:");
            //iterate through all loaded modules
            Iterator it = loadedModules.keySet().iterator();
            while (it.hasNext()) {
                //shut down each loaded module
                String modname = (String)it.next();
                unloadModule(modname);
                //we have removed a module from the map, so iterator needs to be re-initialized!
                it = loadedModules.keySet().iterator();
            }
        }
 
        //shut down packet transport systems
        if (!packetTransports.isEmpty()) {
            _debug.println("Shutting down packet transport systems");
            Iterator it = packetTransports.iterator();
            while (it.hasNext()) {
                MbPacketTransport t = (MbPacketTransport)it.next();
                if (t!=null) {
                    t.shutdown();
                }
            }
        }
 
        _info.println("Macbeth kernel successfully shut down");
 
        //shut down stream logging
        if (_log!=null) {
            _log.close();
        }
 
        //shutdown MbComponent
        super.shutdown();
    }
 
    /**
     * Will be called when a packet needs to be delivered to
     * its specified destination module.
     * @param p The packet that needs to be handled.
     */
    public void handlePacket(MbPacket p) {
        //iterate through all registered packet transports
        Iterator it = packetTransports.iterator();
        boolean deliverySuccessful = false;
        while (it.hasNext()) {
            //try to deliver with each transport
            MbPacketTransport t = (MbPacketTransport)it.next();
            if (t!=null) {
                try {
                    deliverySuccessful = t.deliverPacket(p);
                } catch (MbPacketTransport.MbPacketDeliveryException e) {
                    //the transport attempted to deliver the packet, but failed
                    _errors.println("Packet delivery error: " + e.getMessage());
                    //dump the packet
                    packetDumper.dumpPacket(p,t.getName() + " attempted to deliver the packet, but failed with the message \"" + e.getMessage() + "\"");
                    //and get out of here
                    return;
                }
                //if delivery was successful
                if (deliverySuccessful) {
                    //get out of here
                    return;
                }
            }
        }
        //no transport could deliver the packet, so dump it
        packetDumper.dumpPacket(p,"None of the transports could deliver this packet!");
    }
 
 
    /**
     * A data handler for the XML-configuration file parser.
     */
    public class ConfigDataHandler implements XMLDataHandler {
        private String currentEvent = null;
 
        public void XMLstartElement(String element, HashMap attributes) {
            if (element.equals("list")) {
                if (attributes.containsKey("name")) {
                    dataRepository.advancedBuild_BeginList((String)attributes.get("name"));
                }
                else {
                    _errors.println("Syntax error in '" + configFile + "': 'name'-attribute missing in 'list'-tag!");
                }
            }
            else if (element.equals("item")) {
                dataRepository.advancedBuild_BeginListItem();
            }
            else if (element.equals("field")) {
                if (attributes.containsKey("name") && attributes.containsKey("value")) {
                    dataRepository.advancedBuild_PutField((String)attributes.get("name"), (String)attributes.get("value"));
                }
                else {
                    _errors.println("Syntax error in '" + configFile + "': 'name' and/or 'value'-attributes missing in 'datafield'-tag!");
                }
            }
            else if (element.equalsIgnoreCase("option")) {
                if (attributes.containsKey("name") && attributes.containsKey("value")) {
                    options.putField((String)attributes.get("name"), (String)attributes.get("value"));
                }
                else {
                    _errors.println("Syntax error in '" + configFile + "': 'name'- and/or 'value'-attributes are missing in an 'option'-tag!");
                }
            }
            else if (element.equalsIgnoreCase("event")) {
                if (attributes.containsKey("name")) {
                    currentEvent = (String) attributes.get("name");
                }
                else {
                    _errors.println("Syntax error in '" + configFile + "': 'name'-attribute missing in an 'event'-tag!");
                }
            }
            else if (element.equalsIgnoreCase("do")) {
                if (attributes.containsKey("action")) {
                    String action = (String) attributes.get("action");
                    String params = (String) attributes.get("params");
                    //get the list of actions that are associated with this event so far
                    List actionList = (List) scriptEventActions.get(currentEvent);
                    //is this the first action associated with this event?
                    if (actionList==null) {
                        //if so, a new list needs to be created
                        actionList = new LinkedList();
                        //..and put into the events-actions-map
                        scriptEventActions.put(currentEvent,actionList);
                    }
                    //now, add the new action to the list
                    actionList.add(new MbAction(action, params));
                }
                else {
                    _errors.println("Syntax error in '" + configFile + "': 'action'-attribute missing in a 'do'-tag!");
                }
            }
        }
 
        public void XMLendElement(String element) {
            if (element.equals("list")) {
                dataRepository.advancedBuild_EndList();
            }
            else if (element.equals("item")) {
                dataRepository.advancedBuild_EndListItem();
            }
            else if (element.equals("event")) {
                currentEvent = null;
            }
        }
        public void XMLelementData(String data) {}
        public void XMLdocumentStart() {}
        public void XMLdocumentEnd() {}
    }
 
 
    /**
     * A packet dumper. This is invoked to kill packets that cannot be
     * delivered. All packet dumps will be logged to a file,
     */
    protected class PacketDumper {
        protected PrintStream log;
        protected String startupTime;
        protected String startupTime2;
        protected int packetsDumped;
 
        public PacketDumper() {
            //remember the startup time, because when packets are dumped for the first time
            //we will need to create a file whose name contains our startup time.
            startupTime = MyDateTime.now();
            startupTime2 = MyDateTime.now("yyyy-MM-dd HH_mm_ss");
            packetsDumped = 0;
        }
 
        protected void finalize() throws Throwable {
            if (log != null) {
                //close log stream
                log.flush();
                log.close();
            }
            super.finalize();
        }
 
        /**
         * Dumps a packet. Call this when a packet is invalid or the packet destination
         * cannot be found. A log event will be created and the packet will be killed.
         * @param p The packet that is invalid somehow, and thus needs to be dumped.
         * @param reason The reason why the packet needs to be dumped.
         */
        public void dumpPacket(MbPacket p, String reason) {
            if (log == null) {
                //create log output stream
                try {
                    log = new PrintStream(new FileOutputStream("dumped packets " + startupTime2 + ".log"));
                    log.println("Macbeth session started at " + startupTime + MySystem.lineBreak);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
            }
            String now = MyDateTime.now();
            log.println("--Packet dump log event-----------------------------------------------");
            log.println("[" + now + "]");
            log.println("Dump reason:");
            log.println(reason);
            log.println("Packet was:");
            log.println(p.serializeToString());
            log.println("----------------------------------------------------------------------");
            log.println();
            _info.println("A packet was dumped! (Reason: " + reason + ")");
            p = null;
            packetsDumped++;
        }
    }
 
}
 
Subversion Repositories HomeAutomation

(root)/trunk/MacBeth/src/Macbeth/System/MbKernel.java @ 73 – Rev 18 → 73
