client/alerters/IRC__Alerter.java

//---PACKAGE DECLARATION---
package uk.ac.ukc.iscream.client.alerters;

//---IMPORTS---
import uk.ac.ukc.iscream.client.*;
import uk.ac.ukc.iscream.core.*;
import uk.ac.ukc.iscream.util.*;
import uk.ac.ukc.iscream.componentmanager.*;

import java.io.*;
import java.net.*;
import java.util.*;
import java.text.*;

/**
 * This Alert sends an IRC message.
 *
 * Clean shutdown could be achieved by stopping the run() method in the
 * IRCBot inner class.
 *
 * @author  $Author: ajm4 $
 * @version $Id: IRC__Alerter.java,v 1.17 2001/03/06 02:33:55 ajm4 Exp $
 */
public class IRC__Alerter implements PluginAlerter {

//---FINAL ATTRIBUTES---

    /**
     * The current CVS revision of this class
     */
    public final String REVISION = "$Revision: 1.17 $";
    
    /**
     * A description of this alerter
     */
    public final String DESC = "Sends alerts on an IRC channel";
    
    /**
     * The default reconnect delay in seconds
     */
    public final int DEFAULT_RECONNECT_DELAY = 30;
    
    public final String DEFAULT_LEVEL = Alert.alertLevels[0];
    
    public final String NOT_CONFIGURED = "<NOT CONFIGURED>";
    
//---STATIC METHODS---

//---CONSTRUCTORS---

    public IRC__Alerter() {
                        
        // connect to the IRC server
        _ircbot = new IRCBot();
        _ircbot.start();
        _startTime = System.currentTimeMillis();
        
        _logger.write(toString(), Logger.SYSINIT, "IRC Alerter started");
    }

//---PUBLIC METHODS---

    public void sendAlert(Alert alert) {
        // only send alerts if we're active
        if(_active) {
            ConfigurationProxy cp = ConfigurationProxy.getInstance();
            
            String levelName;
            try {
                levelName = cp.getProperty(_name, "Alerter.IRC.level");
            } catch (PropertyNotFoundException e) {
                levelName = DEFAULT_LEVEL;
                _logger.write(toString(), Logger.WARNING, "Alerter.IRC.level value unavailable using default of " + levelName);
            }
            int level = StringUtils.getStringPos(levelName, Alert.alertLevels);
            // only send if it's equal (or above) our level
            if(((alert.getLevel() == 0) && (alert.getLastLevel() >= level)) || (alert.getLevel() >= level)) {
                String alertType = Alert.alertLevels[alert.getLevel()];
                String thresholdType = Alert.thresholdLevels[alert.getThreshold()];
                String timeFirstSince = DateUtils.formatTime(System.currentTimeMillis() - alert.getInitialAlertTime(), "%DAYS% days, %HOURS% hours, %MINS% mins, and %SECS% secs");
                String timeFirstOccured = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, Locale.UK).format(new Date(alert.getInitialAlertTime()));
                // sort out the message               
                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 = StringUtils.replaceText(message, "%level%", alertType);
                message = StringUtils.replaceText(message, "%threshold%", thresholdType);
                message = StringUtils.replaceText(message, "%source%", alert.getSource());
                message = StringUtils.replaceText(message, "%value%", alert.getValue());
                message = StringUtils.replaceText(message, "%thresholdValue%", alert.getThresholdValue());
                message = StringUtils.replaceText(message, "%attributeName%", alert.getAttributeName());
                message = StringUtils.replaceText(message, "%timeTillNextAlert%",  getTimeString(Long.parseLong(alert.getTimeTillNextAlert())));
                message = StringUtils.replaceText(message, "%timeSinceFirstAlert%", timeFirstSince);
                message = StringUtils.replaceText(message, "%timeOfFirstAlert%", timeFirstOccured);
                
                // send the message
                _logger.write(toString(), Logger.DEBUG, "Sending " + _name + " at "+ alertType + " level");
                _ircbot.sendMsg(message);
                _lastAlert = message;
                _lastAlertTime = System.currentTimeMillis();
                _alertCount ++;
            }
        }
        else {
            _ignoredCount ++;
        }
    }

    /**
     * Overrides the {@link java.lang.Object#toString() Object.toString()}
     * method to provide clean logging (every class should have this).
     *
     * This uses the uk.ac.ukc.iscream.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 filter does
     */
    public String getDescription(){
        return DESC;
    }

//---PRIVATE METHODS---

    private String getTimeString(long time) {
        String timeString = null;
        if (time >= 60) {
            timeString = (time / 60) + " minute(s)";
        } else if (time >= 3600) {
            timeString = ((time/60) / 60) + " hour(s)";
        } else {
            timeString = time + " second(s)";
        }
        return timeString;
    }

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

//---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 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 Alert";

    /**
     * This holds a reference to the
     * system logger that is being used.
     */
    private Logger _logger = ReferenceManager.getInstance().getLogger();

//---STATIC ATTRIBUTES---

//---INNER CLASSES---

    /**
     * This class provides some basic IRCBot functionality. It connects
     * to a specified server, and will remain there until told to
     * leave. Whilst connected it can send a message or a notice to
     * the server.
     */
    class IRCBot extends Thread {
        
        public static final String DEFAULT_STARTUP_NOTICE = "i-scream ircbot starting...";
        
        /**
         * Main thread loop, this part of the class listens for
         * messages from the server, and acts accordingly. At the
         * present moment it only responds to pings.
         */
        public void run() {
            // so we can stop if required
            boolean run = true;
            while(run) {
                // flag so we can stop the loop
                boolean doRead = true;
                // get the startup notice
                String startupNotice;
                try {
                    startupNotice = ConfigurationProxy.getInstance().getProperty(_name, "Alerter.IRC.startupNotice");
                } catch (PropertyNotFoundException e) {
                    startupNotice = DEFAULT_STARTUP_NOTICE;
                    _logger.write(this.toString(), Logger.WARNING, "Configuration error: "+e);
                }
                // connect to the IRC server
                try {
                    connect();
                    sendNotice(startupNotice);
                } catch(IOException e) {
                    doRead=false;
                    _logger.write(this.toString(), Logger.ERROR, "Error connecting: "+e);
                }
                while(doRead) {
                    try {
                        // read a command
                        String cmd = _socketIn.readLine();
                        // if we have a null, we've lost contact
                        if(cmd == null) {
                            throw new IOException("End of stream reached");
                        }
                        // let another method deal with the input
                        handleInput(cmd);
                    } catch (IOException e) {
                        // comms failure, maybe our link is dead.
                        _logger.write(this.toString(), Logger.ERROR, "Communication error: "+e);
                        // stop, and loop round for a reconnect.
                        doRead = false;
                    }
                }
                // make sure we're disconnected
                try {
                    disconnect();
                } catch (IOException e) {
                    _logger.write(this.toString(), Logger.ERROR, "Communication error: "+e);
                }
                
                // comms have failed, so wait a while and reconnect
                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");
                }
                try {
                    Thread.sleep(delayTime * 1000);
                } catch (InterruptedException e) {}
            }
            // maybe disconnect here ? - shutdown method not implemented yet
            //disconnect();
        }
        
        /**
         * Sends a message to the channel.
         *
         * @param msg The message to send
         */
        public void sendMsg(String msg) {
            _socketOut.println("PRIVMSG "+_channel+" :"+msg);
            // wait a second before returning...
            // this ensures messages can't be sent too fast
            try {Thread.sleep(1000);} catch (InterruptedException e) {}
        }
        
        /**
         * Sends a message to the channel.
         *
         * @param user The user to send to
         * @param msg The message to send
         */
        public void sendPrivMsg(String user, String msg) {
            _socketOut.println("PRIVMSG "+user+" :"+msg);
            // wait a second before returning...
            // this ensures messages can't be sent too fast
            try {Thread.sleep(1000);} catch (InterruptedException e) {}
        }
        
        /**
         * Sends an action to the channel.
         *
         * @param msg the action message
         */
        public void sendAction(String msg) {
            char esc = 001;
            sendMsg(esc+"ACTION "+msg+esc);
            // wait a second before returning...
            // this ensures messages can't be sent too fast
            try {Thread.sleep(1000);} catch (InterruptedException e) {}
        }
        
        /**
         * Sends a notice to the channel.
         *
         * @param msg The notice to send
         */
        public void sendNotice(String msg) {
            _socketOut.println("NOTICE "+_channel+" :"+msg);
            // wait a second before returning...
            // this ensures messages can't be sent too fast
            try {Thread.sleep(1000);} catch (InterruptedException e) {}
        }
        
        /**
         * Connect to the IRC server, log in, and join the channel.
         *
         * @throws IOException if the connection fails
         */
        public void connect() throws IOException {
            ConfigurationProxy cp = ConfigurationProxy.getInstance();
            // setup the socket, reader and writer
            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");
            }
            _socket = new Socket(server, port);
            _socketIn = new BufferedReader(new InputStreamReader(_socket.getInputStream()));
            _socketOut = new PrintWriter(_socket.getOutputStream(), true);
            //_socketOut.println("PASS");
            // send USER details
            String user, comment;
            try {
                user = cp.getProperty(_name, "Alerter.IRC.user");
                comment = cp.getProperty(_name, "Alerter.IRC.comment");
            } catch (PropertyNotFoundException e) {
                _logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
                throw new IOException("Can't get user details due to configuration error");
            }
            _socketOut.println("USER "+user+" 8 * :"+comment);
            // attempt to get a nick
            String nickList;
            try {
                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 nickname due to configuration error");
            }
            StringTokenizer st = new StringTokenizer(nickList, ";");
            boolean ok = false;
            // try until we exhaust our list
            while(!ok && st.hasMoreTokens()) {
                String nick = st.nextToken();
                _socketOut.println("NICK "+nick);
                // get a "yes" or "no" response back
                String response = "";
                do {
                    response = _socketIn.readLine();
                    if(response==null) {
                        throw new IOException("Communication error whilst logging in");
                    }
                } while(response.indexOf("001")==-1 && response.indexOf("433")==-1);
                // see if it was a yes
                if(response.indexOf("001")!=-1) {
                    // great, we're logged in !
                    ok = true;
                    // store the name we're using
                    _nickname = nick;
                }
                else {
                    // log we couldn't get the name
                    _logger.write(this.toString(), Logger.WARNING, "Nickname in use: "+nick);
                }
            }
            if(!ok) {
                // oh dear, we couldn't get on.
                throw new IOException("All nicknames in use");
            }
            // join the channel
            try {
                _channel = cp.getProperty(_name, "Alerter.IRC.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");
            }
            _socketOut.println("JOIN "+_channel);
            // allow alerts
            _active = true;
        }
        
        /**
         * Disconnect "nicely" from the IRC server.
         *
         * @throws IOException if the disconnection fails
         */
        public void disconnect() throws IOException {
            // stop alerts
            _active = false;
            // send proper QUIT
            _socketOut.println("QUIT : iscreamBot component shutting down...");
            // close the socket
            _socketOut.close();
            _socketIn.close();
            _socket.close();
        }
        
        /**
         * Overrides the {@link java.lang.Object#toString() Object.toString()}
         * method to provide clean logging (every class should have this).
         *
         * This uses the uk.ac.ukc.iscream.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);
        }
        
        /**
         * Deals with incoming lines from the server.
         *
         * @param line the line to deal with
         */
        private void handleInput(String line) {
            ConfigurationProxy cp = ConfigurationProxy.getInstance();
            // if it's a PING...
            if(line.startsWith("PING")) {
                // ...send a PONG
                _socketOut.println("PONG" + line.substring(4));
            }
            // see if it's for us
            else if(getMsg(line).startsWith(_nickname+",") || getMsg(line).startsWith(_nickname+":") || getMsg(line).startsWith(_nickname+" ")) {
                // setup some String's
                String stopCommand, startCommand, timeSinceLastAlertCommand, lastAlertCommand, joinCommand;
                String nickChangeCommand, versionCommand, helpCommand, statCommand, uptimeCommand;
                // get the command set
                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;
                }
                
                // we have a message for us
                String message = getMsg(line).substring(_nickname.length());
                if(message.indexOf(stopCommand)!=-1) {
                    _active = false;
                    sendMsg(getMsgSender(line)+", alerts have been stopped");
                }
                else if(message.indexOf(startCommand)!=-1) {
                    _active = true;
                    sendMsg(getMsgSender(line)+", alerts have been activated");
                }
                // this needs to go here if it contains the same words as the lastAlertCommand
                else if(message.indexOf(timeSinceLastAlertCommand)!=-1) {
                    if(_lastAlertTime != -1) {
                        long uptime = (System.currentTimeMillis() - _lastAlertTime) / 1000;
                        String uptimeText = DateUtils.formatTime(uptime, "%DAYS% days, %HOURS% hours, %MINS% mins, and %SECS% secs");
                        sendMsg(getMsgSender(line)+", I last sent an alert "+uptimeText+ " ago");
                    }
                    else {
                        sendMsg(getMsgSender(line)+", I've never sent an alert!");
                    }
                }
                else if(message.indexOf(lastAlertCommand)!=-1) {
                    if(_lastAlertTime != -1) {
                        String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, Locale.UK).format(new Date(_lastAlertTime));
                        sendMsg(getMsgSender(line)+", last alert was at "+date+"; "+_lastAlert);
                    }
                    else {
                        sendMsg(getMsgSender(line)+", I've never sent an alert!");
                    }
                    
                }
                else if(message.indexOf(joinCommand)!=-1) {
                    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);
                    sendMsg(getMsgSender(line)+", okay, I'm off to "+newChan);
                    _socketOut.println("PART "+_channel);
                    _socketOut.println("JOIN "+newChan);
                    _channel = newChan;
                }
                else if(message.indexOf(nickChangeCommand)!=-1) {
                    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);
                    sendMsg(getMsgSender(line)+", okay, changing my nickname to "+newNick);
                    _socketOut.println("NICK "+newNick);
                    _nickname = newNick;
                }
                else if(message.indexOf(versionCommand)!=-1) {
                    sendMsg(getMsgSender(line)+", I am version "+REVISION.substring(11, REVISION.length() -2)+" of the i-scream alerting bot");
                }
                else if(message.indexOf(helpCommand)!=-1) {
                    sendPrivMsg(getMsgSender(line), "Hello, I am the i-scream alerting bot version "+REVISION.substring(11, REVISION.length() -2));
                    sendPrivMsg(getMsgSender(line), "I understand the following commands;");
                    sendPrivMsg(getMsgSender(line), stopCommand);
                    sendPrivMsg(getMsgSender(line), startCommand);
                    sendPrivMsg(getMsgSender(line), lastAlertCommand);
                    sendPrivMsg(getMsgSender(line), joinCommand);
                    sendPrivMsg(getMsgSender(line), nickChangeCommand);
                    sendPrivMsg(getMsgSender(line), statCommand);
                    sendPrivMsg(getMsgSender(line), uptimeCommand);
                    sendPrivMsg(getMsgSender(line), timeSinceLastAlertCommand);
                    sendPrivMsg(getMsgSender(line), helpCommand);
                }
                else if(message.indexOf(statCommand)!=-1) {
                    sendMsg(getMsgSender(line)+", I have sent a total of "+_alertCount+" alerts, and ignored a total of "+_ignoredCount+"!");
                }
                else if(message.indexOf(uptimeCommand)!=-1) {
                    long uptime = (System.currentTimeMillis() - _startTime) / 1000;
                    String uptimeText = DateUtils.formatTime(uptime, "%DAYS% days, %HOURS% hours, %MINS% mins, and %SECS% secs");
                    sendMsg(getMsgSender(line)+", I have been running for "+uptimeText);
                }
                else if(message.indexOf("ping")!=-1) {
                    sendMsg("pong");
                }
                else if(message.indexOf("do a jibble dance")!=-1) {
                    // little joke :)
                    sendAction("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);
                    }
                    sendMsg(getMsgSender(line)+", "+rejectMessage);
                }
            }
            else if(line.indexOf(_nickname)!=-1 && line.indexOf(_channel)!=-1 && line.indexOf("KICK")!=-1) {
                sendPrivMsg(getMsgSender(line), "That wasn't a nice thing to do...");
                try {
                    _channel = cp.getProperty(_name, "Alerter.IRC.channel");
                } catch(PropertyNotFoundException e) {
                    _logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
                }
                _socketOut.println("JOIN "+_channel);
            }
        }
        
        /**
         * Strips the header from a message line
         *
         * @param line the line to strip
         * @return the message from the line
         */
        private String getMsg(String line) {
            String result = "";
            if(line.indexOf("PRIVMSG")!=-1) {
                int firstColon = line.indexOf(":");
                if(firstColon != -1) {
                    int secondColon = line.indexOf(":", firstColon+1);
                    if(secondColon != -1) {
                        result = line.substring(secondColon+1);
                    }
                }
            }
            return result;
        }
        
        /**
         * Finds out the sender of the message
         *
         * @param line the line to look for a sender in
         * @return the sender
         */
        private String getMsgSender(String line) {
            String result = "";
            int colon = line.indexOf(":");
            int excl = line.indexOf("!");
            if(colon!=-1 && excl!=-1) {
                result = line.substring(colon+1, excl);
            }
            return result;
        }
        
        /**
         * The socket connected to the server
         */
        private Socket _socket;
        
        /**
         * The writer
         */
        private PrintWriter _socketOut;
        
        /**
         * The reader
         */
        private BufferedReader _socketIn;
        
        /**
         * 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.18
Committed:	Thu Mar 8 13:43:54 2001 UTC (23 years, 2 months ago) by tdb
Branch:	MAIN
Changes since 1.17:	+16 -5 lines
Log Message:	Added a count of "ignored" alerts - ie. when in stopped mode.