client/alerters/IRC__Alerter.java

//---PACKAGE DECLARATION---
package uk.org.iscream.cms.server.client.alerters;

//---IMPORTS---
import uk.org.iscream.cms.server.client.*;
import uk.org.iscream.cms.server.core.*;
import uk.org.iscream.cms.server.util.*;
import uk.org.iscream.cms.server.componentmanager.*;
import java.io.*;
import java.net.*;
import java.util.*;
import java.text.DateFormat;
import org.jibble.pircbot.*;

/**
 * This Alert sends an IRC message.
 *
 * Clean shutdown could be achieved by stopping the run() method in the
 * IRCBot inner class.
 *
 * @author  $Author: tdb $
 * @version $Id: IRC__Alerter.java,v 1.30.2.3 2002/02/05 18:00:15 tdb Exp $
 */
public class IRC__Alerter extends AlerterSkeleton {

//---FINAL ATTRIBUTES---

    /**
     * The current CVS revision of this class
     */
    public final String REVISION = "$Revision: 1.30.2.3 $";
    
    /**
     * A description of this alerter
     */
    public final String DESC = "Sends alerts on an IRC channel";
    
//---STATIC METHODS---

//---CONSTRUCTORS---
    
    public IRC__Alerter() {
        super();
        // construct and initialise the bot
        _ircbot = new IRCBot();
        _ircbot.setVerbose(false);
        Thread ircThread = new Thread(_ircbot);
        // set it's name and start it
        ircThread.setName("client.IRC__Alerter$IRCBot");
        ircThread.start();
        // log our start time
        _startTime = System.currentTimeMillis();
        _logger.write(toString(), Logger.SYSINIT, "IRC Alerter started");
    }

//---PUBLIC METHODS---

    /**
     * Implements the abstract method from the skeleton class.
     * This method will attempt to send an alert
     * message over the IRC channel.
     *
     * @param alert the alert to send
     */
    public void sendAlert(Alert alert) {
        // sort out the message       
        String alertType = Alert.alertLevels[alert.getLevel()];        
        String message;
        try {
            message = _cp.getProperty(_name, "Alerter.IRC.message");
        } catch (PropertyNotFoundException e) {
            message = NOT_CONFIGURED;
            _logger.write(toString(), Logger.WARNING, "Alerter.IRC.message value unavailable using default of " + message);
        }
        message = processAlertMessage(message, alert);        
        // only send alerts if we're active
        if(_active) {           
            // send the message
            _logger.write(toString(), Logger.DEBUG, "Sending " + _name + " at "+ alertType + " level");
            _ircbot.sendMessage(message);
            // count sent alerts
            _alertCount++;
        } else {
            // don't send, but keep a count that we ignored it
            _ignoredCount++;
        }
        // we'll always store the "last alert", regardless
        // of whether we actually display it or not
        _lastAlert = message;
        _lastAlertTime = System.currentTimeMillis();
    }

    /**
     * Overrides the {@link java.lang.Object#toString() Object.toString()}
     * method to provide clean logging (every class should have this).
     *
     * This uses the uk.org.iscream.cms.server.util.NameFormat class
     * to format the toString()
     *
     * @return the name of this class and its CVS revision
     */
    public String toString() {
        return FormatName.getName(
            _name,
            getClass().getName(),
            REVISION);
    }

    /** 
     * Return the String representation of what the alerter does
     *
     * @return the description
     */
    public String getDescription(){
        return DESC;
    }

//---PRIVATE METHODS---

//---ACCESSOR/MUTATOR METHODS---

    /**
     * Returns the "friendly" name of this class. This
     * is simply an accessor for _name, required due to
     * inheritance issues with extending AlerterSkeleton.
     *
     * @return the friendly name
     */
    protected String getFName() {
        return _name;
    }

//---ATTRIBUTES---
    
    /**
     * A reference to the IRCBot
     */
    private IRCBot _ircbot;
    
    /**
     * Are we "active"
     */
    private boolean _active = false;
    
    /**
     * The last alert that was sent
     */
    private String _lastAlert = "no alerts have been sent";
    
    /**
     * The time of the last alert
     */
    private long _lastAlertTime = -1;
    
    /**
     * Number of alerts sent
     */
    private int _alertCount = 0;
    
    /**
     * Number of alerts ignored when in "stopped" mode
     */
    private int _ignoredCount = 0;
    
    /**
     * Time of IRCBot startup
     */
    private long _startTime;
    
    /**
     * This holds a reference to the
     * system logger that is being used.
     */
    protected Logger _logger = ReferenceManager.getInstance().getLogger();
    
    /**
     * This is the friendly identifier of the
     * component this class is running in.
     * eg, a Filter may be called "filter1",
     * If this class does not have an owning
     * component,  a name from the configuration
     * can be placed here.  This name could also
     * be changed to null for utility classes.
     */
    private String _name = "IRC";

//---STATIC ATTRIBUTES---

//---INNER CLASSES---

    class IRCBot extends PircBot implements Runnable {
        
        /**
         * The default reconnect delay in seconds
         */
        public final int DEFAULT_RECONNECT_DELAY = 30;
        
        /**
         * Attempt to kick-start the IRCBot into action. Will
         * keep calling init() until it doesn't throw an
         * an IOException (which will only be thrown if there
         * is an error initialising). After a successful call
         * to init() the method finishes.
         */
        public void run() {
            while(true) {
                try {
                    init();
                    break;
                }
                catch (IOException e) {
                    _logger.write(this.toString(), Logger.ERROR, "Error initialising IRCBot: "+e);
                    // wait for a while, defined in the config
                    reconnectSleep();
                }
            }
        }
        
        /**
         * Connects the bot to an irc server and joins a channel,
         * using details supplied from the i-scream configuration
         * system. If this method completes without an exception
         * one can presume the bot is ready for use.
         *
         * @throws IOException if there is any problem initialising
         */
        private void init() throws IOException {
            _logger.write(this.toString(), Logger.DEBUG, "Initialising IRCBot...");
            
            // get a hook on the configuration system
            ConfigurationProxy cp = ConfigurationProxy.getInstance();
            
            // get hold of the server details
            String server;
            int port;
            try {
                server = cp.getProperty(_name, "Alerter.IRC.IRCServer");
                port = Integer.parseInt(cp.getProperty(_name, "Alerter.IRC.IRCPort"));
            } catch (PropertyNotFoundException e) {
                _logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
                throw new IOException("Can't get irc server details due to configuration error");
            } catch (NumberFormatException e) {
                _logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
                throw new IOException("Can't get irc server details due to malformed configuration");
            }
            
            // get hold of the user details and nickname list
            String user, nickList;
            try {
                user = cp.getProperty(_name, "Alerter.IRC.user");
                nickList = cp.getProperty(_name, "Alerter.IRC.nickList");
            } catch (PropertyNotFoundException e) {
                _logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
                throw new IOException("Can't get user/nickname details due to configuration error");
            }
            
            // get hold of comment and finger information
            //  -- we're not too fussed if these aren't set
            String comment = "Alerter.IRC.comment is undefined";
            String finger = "Alerter.IRC.finger is undefined";
            try {
                comment = cp.getProperty(_name, "Alerter.IRC.comment");
                finger = cp.getProperty(_name, "Alerter.IRC.finger");
            } catch (PropertyNotFoundException e) {
                _logger.write(this.toString(), Logger.WARNING, "Configuration warning, using default: "+e);
            }
            
            // put these details into the bot
            this.setLogin(user);
            this.setVersion(comment);
            this.setFinger(finger);
            
            // attempt to connect, trying each nickname
            // in turn until sucessfully connected
            StringTokenizer st = new StringTokenizer(nickList, ";");
            boolean ok = false;
            while(!ok && st.hasMoreTokens()) {
                String nick = st.nextToken();
                try {
                    // try to connect with a nickname
                    _logger.write(this.toString(), Logger.DEBUG, "Trying nick: "+nick);
                    this.setName(nick);
                    this.connect(server, port);
                    // at this point we know the nickname was accepted
                    _nickname = nick;
                    ok = true;
                }
                catch(IOException e) {
                    _logger.write(this.toString(), Logger.ERROR, "IO error when connecting to server: "+e);
                    throw new IOException("IO error when connecting to server");
                }
                catch(IrcException e) {
                    _logger.write(this.toString(), Logger.ERROR, "IRC error when connecting to server: "+e);
                    throw new IOException("IRC error when connecting to server");
                }
                catch(NickAlreadyInUseException e) {
                    _logger.write(this.toString(), Logger.ERROR, "Nickname "+nick+" is already in use: "+e);
                    // don't do anything, instead just loop round
                    // and try the next nickname in the list
                }
            }
            if(!ok) {
                // must have tried all the nicknames, best bail out
                _logger.write(this.toString(), Logger.ERROR, "All nicknames already in use");
                throw new IOException("All nicknames already in use");
            }
            
            // get hold of the channel details, and attempt
            // to join the specified channel
            try {
                _channel = cp.getProperty(_name, "Alerter.IRC.channel");
                this.joinChannel(_channel);
            } catch (PropertyNotFoundException e) {
                _logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
                throw new IOException("Can't get channel name due to configuration error");
            }
            
            // get hold of the startup notice, and send
            // it if it's defined
            String startupNotice;
            try {
                startupNotice = ConfigurationProxy.getInstance().getProperty(_name, "Alerter.IRC.startupNotice");
                sendNotice(_channel, startupNotice);
            } catch (PropertyNotFoundException e) {
                _logger.write(this.toString(), Logger.DEBUG, "Startup notice not defined, so not sending: "+e);
            }
            
            // at this point initialisation is complete, so
            // we can return and set this flag to allow alerts
            _active = true;
        }
        
        /**
         * Send a message to the current channel.
         *
         * @param message The message to send
         */
        private void sendMessage(String message) {
            sendMessage(_channel, message);
        }
        
        /**
         * If we get disconnected this method will be
         * called, so we must take action. We'll simply
         * keep trying to reinitialise, and thus
         * reconnect to the server.
         */
        public void onDisconnect() {
            // stop alerts being sent for now
            _active = false;
            while(true) {
                // wait for a while, defined in the config
                reconnectSleep();
                try {
                    init();
                    break;
                }
                catch (IOException e) {
                    _logger.write(this.toString(), Logger.ERROR, "Error initialising IRCBot: "+e);
                }
            }
        }
        
        /**
         * If we receive a message this method will
         * be called. We'll check if the message is
         * for us, and call handleInput if it is.
         *
         * @param channel The channel the message came from
         * @param sender The sender of the message
         * @param login The login of the sender
         * @param hostname The hostname of the sender
         * @param message The message sent
         */
        public void onMessage(String channel, String sender, String login, String hostname, String message) {
            String trimmedMessage = isForMe(message);
            // if trimmedMessage is null, it's not for us
            if(trimmedMessage != null) {
                handleInput(trimmedMessage, channel);
            }
        }
        
        /**
         * If we receive a private message this method
         * will be called. No need to check if it's for
         * us -- it has to be if it's a private message.
         *
         * @param sender The sender of the message
         * @param login The login of the sender
         * @param hostname The hostname of the sender
         * @param message The message sent
         */
        public void onPrivateMessage(String sender, String login, String hostname, String message) {
            handleInput(message, sender);
        }
        
        /**
         * If we receive a nick change message, this
         * method gets called. We don't care about
         * other users changing their nick, so we only
         * take notice if our nick changes. If it does
         * we need to change our internal nickname
         * state.
         *
         * @param oldNick the old nickname
         * @param login the login of the nick changer
         * @param hostname the hostname of the nick changer
         * @param newNick the new nickname
         */
        public void onNickChange(String oldNick, String login, String hostname, String newNick) {
            if(oldNick.equals(_nickname)) {
                _nickname = newNick;
            }
        }
        
        /**
         * If we receive a kick message this method
         * gets called. We only take notice if it's
         * us getting kicked, and then we'll rejoin
         * the channel after a short wait.
         *
         * @param channel the channel the kick happened on
         * @param kickerNick the person who performed the kick
         * @param kickerLogin the login of the person who performed the kick
         * @param kickerHostname the hostname of the person who performed the kick
         * @param recipientNick the nickname of the person being kicked
         * @param reason the reason for the kick
         */
        public void onKick(String channel, String kickerNick, String kickerLogin, String kickerHostname, String recipientNick, String reason) {
            if(recipientNick.equals(_nickname) && channel.equals(_channel)) {
                // remind the person it's not very nice :)
                sendMessage(kickerNick, "That wasn't a nice thing to do...");
                // get hold of the channel details, in case they've changed
                try {
                    _channel = ConfigurationProxy.getInstance().getProperty(_name, "Alerter.IRC.channel");
                } catch(PropertyNotFoundException e) {
                    _logger.write(this.toString(), Logger.ERROR, "Can't get channel name due to configuration error: "+e);
                }
                // wait for a while, defined in the config
                reconnectSleep();
                // we'll try and rejoin the channel regardless
                // otherwise we might end up doing nothing!
                joinChannel(_channel);
            }
        }
        
        /**
         * This method handles input directed to us, and
         * responds accordingly if required.
         *
         * nb. matching user input is quite bad right now,
         *     and should be improved one day.
         *
         * @param message the message from someone
         * @param source where the message came from, so we know where to send the response
         */
        private void handleInput(String message, String source) {
            // get hold of the configuration system
            ConfigurationProxy cp = ConfigurationProxy.getInstance();
            // setup some String's
            String stopCommand, startCommand, timeSinceLastAlertCommand, lastAlertCommand, joinCommand;
            String nickChangeCommand, versionCommand, helpCommand, statCommand, uptimeCommand;
            // get the command set from the configuration
            try {
                stopCommand = cp.getProperty(_name, "Alerter.IRC.stopCommand");
                startCommand = cp.getProperty(_name, "Alerter.IRC.startCommand");
                timeSinceLastAlertCommand = cp.getProperty(_name, "Alerter.IRC.timeSinceLastAlertCommand");
                lastAlertCommand = cp.getProperty(_name, "Alerter.IRC.lastAlertCommand");
                joinCommand = cp.getProperty(_name, "Alerter.IRC.joinCommand");
                nickChangeCommand = cp.getProperty(_name, "Alerter.IRC.nickChangeCommand");
                versionCommand = cp.getProperty(_name, "Alerter.IRC.versionCommand");
                helpCommand = cp.getProperty(_name, "Alerter.IRC.helpCommand");
                statCommand = cp.getProperty(_name, "Alerter.IRC.statCommand");
                uptimeCommand = cp.getProperty(_name, "Alerter.IRC.uptimeCommand");
            } catch (PropertyNotFoundException e) {
                _logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
                // lets bail from handling this line...
                // ...it's gonna be hard without a command set!
                return;
            }
            
            // see if the message matches (loosely!) any
            // of our known commands
            if(message.equalsIgnoreCase(stopCommand)) {
                _active = false;
                sendMessage(source, "alerts have been stopped");
            }
            else if(message.equalsIgnoreCase(startCommand)) {
                _active = true;
                sendMessage(source, "alerts have been activated");
            }
            // this needs to go before lastAlertCommand if it contains
            // the same words as the lastAlertCommand.
            else if(message.equalsIgnoreCase(timeSinceLastAlertCommand)) {
                if(_lastAlertTime != -1) {
                    long uptime = (System.currentTimeMillis() - _lastAlertTime) / 1000;
                    String uptimeText = DateUtils.formatTime(uptime, "%DAYS% days, %HOURS% hours, %MINS% mins, and %SECS% secs");
                    sendMessage(source, "I last sent an alert "+uptimeText+ " ago");
                }
                else {
                    sendMessage(source, "I've never sent an alert!");
                }
            }
            else if(message.equalsIgnoreCase(lastAlertCommand)) {
                if(_lastAlertTime != -1) {
                    String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, Locale.UK).format(new Date(_lastAlertTime));
                    sendMessage(source, "last alert was at "+date+"; "+_lastAlert);
                }
                else {
                    sendMessage(source, "I've never sent an alert!");
                }
                
            }
            else if(message.equalsIgnoreCase(joinCommand)) {
                String joinCmd = joinCommand;
                String newChan = message.substring(message.indexOf(joinCmd) + joinCmd.length() + 1);
                int endOfChan = newChan.indexOf(" ");
                if(endOfChan == -1) {
                    endOfChan = newChan.length();
                }
                newChan = newChan.substring(0, endOfChan);
                if(newChan.equals(_channel)) {
                    sendMessage(source, "I'm already on "+newChan+"!");
                } else {
                    partChannel(_channel);
                    joinChannel(newChan);
                    _channel = newChan;
                }
            }
            else if(message.equalsIgnoreCase(nickChangeCommand)) {
                String nickChangeCmd = nickChangeCommand;
                String newNick = message.substring(message.indexOf(nickChangeCmd) + nickChangeCmd.length() + 1);
                int endOfNick = newNick.indexOf(" ");
                if(endOfNick == -1) {
                    endOfNick = newNick.length();
                }
                newNick = newNick.substring(0, endOfNick);
                changeNick(newNick);
            }
            else if(message.equalsIgnoreCase(versionCommand)) {
                sendMessage(source, "I am version "+REVISION.substring(11, REVISION.length()-2)+" of the i-scream alerting bot");
            }
            else if(message.equalsIgnoreCase(helpCommand)) {
                sendMessage(source, "Hello, I am the i-scream alerting bot version "+REVISION.substring(11, REVISION.length() -2));
                sendMessage(source, "I understand the following commands;");
                sendMessage(source, stopCommand);
                sendMessage(source, startCommand);
                sendMessage(source, lastAlertCommand);
                sendMessage(source, joinCommand);
                sendMessage(source, nickChangeCommand);
                sendMessage(source, statCommand);
                sendMessage(source, uptimeCommand);
                sendMessage(source, timeSinceLastAlertCommand);
                sendMessage(source, helpCommand);
            }
            else if(message.equalsIgnoreCase(statCommand)) {
                sendMessage(source, "I have sent a total of "+_alertCount+" alerts, and ignored a total of "+_ignoredCount+"!");
            }
            else if(message.equalsIgnoreCase(uptimeCommand)) {
                long uptime = (System.currentTimeMillis() - _startTime) / 1000;
                String uptimeText = DateUtils.formatTime(uptime, "%DAYS% days, %HOURS% hours, %MINS% mins, and %SECS% secs");
                sendMessage(source, "I have been running for "+uptimeText);
            }
            else if(message.equalsIgnoreCase("ping")) {
                sendMessage(source, "pong");
            }
            else if(message.equalsIgnoreCase("do a jibble dance")) {
                // little joke :)
                sendAction(source, "jives to the funky beat shouting \"ii--screeeaaammm\"");
            }
            else {
                String rejectMessage = NOT_CONFIGURED;
                try {
                    rejectMessage = cp.getProperty(_name, "Alerter.IRC.rejectMessage");
                } catch(PropertyNotFoundException e) {
                    _logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
                }
                sendMessage(source, rejectMessage);
            }
        }
        
        /**
         * Quick method to check if the message appears
         * to be directed at us. We simply check to see
         * if it starts with our nick in some fashion.
         * This will return null if the message is not
         * for us - thus allowing this method to perform
         * two tasks at once.
         *
         * @param message the message to check
         * @return the message (with our nick removed), or null if it's not for us.
         */
        private String isForMe(String message) {
            // change to lower case to remove
            // case ambiguities
            String nick = _nickname.toLowerCase();
            String msg = message.toLowerCase();
            if(msg.startsWith(nick + ", ") ||
               msg.startsWith(nick + ": ") ||
               msg.startsWith(nick + " ")) {
                // NOTE that the 1 here is hardcoded to be the length
                // of the above 'extra' character (eg , or :)
                return message.substring(nick.length()+1).trim();
            }
            else {
                return null;
            }
        }
        
        /**
         * Sleep for a configurable amount of time and
         * then return. This is used when reconnecting
         * to the server or a channel.
         */
        private void reconnectSleep() {
            int delayTime = 0;
            try {
                delayTime = Integer.parseInt(ConfigurationProxy.getInstance().getProperty(_name, "Alerter.IRC.reconnectDelay"));
            } catch (NumberFormatException e) {
                delayTime = DEFAULT_RECONNECT_DELAY;
                _logger.write(this.toString(), Logger.WARNING, "Erronous Alerter.IRC.reconnectDelay value in configuration using default of " + delayTime + " seconds");
            } catch (PropertyNotFoundException e) {
                delayTime = DEFAULT_RECONNECT_DELAY;
                _logger.write(this.toString(), Logger.WARNING, "Alerter.IRC.reconnectDelay value unavailable using default of " + delayTime + " seconds");
            }
            _logger.write(this.toString(), Logger.ERROR, "Waiting "+delayTime+" seconds for reconnect...");
            try {
                Thread.sleep(delayTime * 1000);
            } catch (InterruptedException e) {}
        }
        
        /**
         * Overrides the {@link java.lang.Object#toString() Object.toString()}
         * method to provide clean logging (every class should have this).
         *
         * This uses the uk.org.iscream.cms.server.util.NameFormat class
         * to format the toString()
         *
         * @return the name of this class and its CVS revision
         */
        public String toString() {
            return FormatName.getName(
                _name,
                getClass().getName(),
                REVISION);
        }
        
        /**
         * Just a reminder to what channel we're on...
         * this can't be dynamic :)
         */
        private String _channel;
        
        /**
         * A reminder of our current nickname...
         */
        private String _nickname;
        
    }

}
Revision:	1.30.2.4
Committed:	Tue Feb 5 21:40:03 2002 UTC (22 years, 3 months ago) by tdb
Branch:	SERVER_PIRCBOT
Changes since 1.30.2.3:	+44 -26 lines
Log Message:	Improved the parsing of user input. Now will only match the exact String for the command - ignoring case sensitivity. Also tweaked the use of the config to stop the bot failing when some non-essential things can't be got from the config.