ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/cms/source/server/uk/org/iscream/cms/server/client/alerters/IRC__Alerter.java

Comparing projects/cms/source/server/uk/org/iscream/cms/server/client/alerters/IRC__Alerter.java (file contents):
Revision 1.6 by tdb, Fri Mar 2 02:46:56 2001 UTC vs.
Revision 1.30.2.1 by tdb, Mon Feb 4 00:14:13 2002 UTC

#	Line 1 | Line 1
1		//---PACKAGE DECLARATION---
2	<	package uk.ac.ukc.iscream.client.alerters;
2	>	package uk.org.iscream.cms.server.client.alerters;
3
4		//---IMPORTS---
5	<	import uk.ac.ukc.iscream.client.*;
6	<	import uk.ac.ukc.iscream.core.*;
7	<	import uk.ac.ukc.iscream.util.*;
8	<	import uk.ac.ukc.iscream.componentmanager.*;
9	<
5	>	import uk.org.iscream.cms.server.client.*;
6	>	import uk.org.iscream.cms.server.core.*;
7	>	import uk.org.iscream.cms.server.util.*;
8	>	import uk.org.iscream.cms.server.componentmanager.*;
9		import java.io.*;
10		import java.net.*;
11	+	import java.util.*;
12	+	import java.text.DateFormat;
13	+	import org.jibble.pircbot.*;
14
15		/**
16		* This Alert sends an IRC message.
17		*
18	+	* Clean shutdown could be achieved by stopping the run() method in the
19	+	* IRCBot inner class.
20	+	*
21		* @author  $Author$
22		* @version $Id$
23		*/
24	<	public class IRC__Alerter implements PluginAlerter {
24	>	public class IRC__Alerter extends AlerterSkeleton {
25
26		//---FINAL ATTRIBUTES---
27
#	Line 25 | Line 30 | public class IRC__Alerter implements PluginAlerter {
30		*/
31		public final String REVISION = "$Revision$";
32
33	+	/**
34	+	* A description of this alerter
35	+	*/
36		public final String DESC = "Sends alerts on an IRC channel";
37
38		//---STATIC METHODS---
39
40		//---CONSTRUCTORS---
41	<
41	>
42		public IRC__Alerter() {
43	<	// get the configuration for this alerter
44	<	Configuration config = ReferenceManager.getInstance().getCM().getConfiguration(_name);
45	<
46	<	// an integer value
47	<	_level = Integer.parseInt(config.getProperty("Alerter.IRC.level"));
48	<	// the hostname of the IRC server
49	<	_IRCServer = config.getProperty("Alerter.IRC.IRCServer");
50	<	// the port number of the IRC server
51	<	_IRCPort = Integer.parseInt(config.getProperty("Alerter.IRC.IRCPort"));
52	<	// the nickname to use
45	<	_nick = config.getProperty("Alerter.IRC.nick");
46	<	// the channel to join
47	<	_channel = config.getProperty("Alerter.IRC.channel");
48	<	// a message with the following: %level% and %message%
49	<	_message = config.getProperty("Alerter.IRC.message");
50	<
51	<	// connect to the IRC server
52	<	_ircbot = null;
53	<	try {
54	<	_ircbot = new IRCBot();
55	<	_ircbot.connect();
56	<	_ircbot.sendNotice("iscreamBot activated");
57	<	} catch(IOException e) {
58	<	_logger.write(toString(), Logger.ERROR, "Error starting IRCBot: "+e);
59	<	}
60	<
43	>	super();
44	>	// construct and initialise the bot
45	>	_ircbot = new IRCBot();
46	>	//_ircbot.setVerbose(true);
47	>	Thread ircThread = new Thread(_ircbot);
48	>	// set it's name and start it
49	>	ircThread.setName("client.IRC__Alerter$IRCBot");
50	>	ircThread.start();
51	>	// log our start time
52	>	_startTime = System.currentTimeMillis();
53		_logger.write(toString(), Logger.SYSINIT, "IRC Alerter started");
54		}
55
56		//---PUBLIC METHODS---
57
58	+	/**
59	+	* Implements the abstract method from the skeleton class.
60	+	* This method will attempt to send an alert
61	+	* message over the IRC channel.
62	+	*
63	+	* @param alert the alert to send
64	+	*/
65		public void sendAlert(Alert alert) {
66	<	// only send if it's equal (or above) our level
67	<	if(alert.getLevel() >= _level) {
68	<	String alertType = Alert.alerts[alert.getLevel()]+"["+String.valueOf(alert.getLevel())+"]";
69	<	// sort out the message
70	<	String message = _message;
71	<	message = StringUtils.replaceText(message, "%level%", alertType);
72	<	message = StringUtils.replaceText(message, "%source%", alert.getSource());
73	<	message = StringUtils.replaceText(message, "%value%", alert.getValue());
74	<	message = StringUtils.replaceText(message, "%thresholdValue%", alert.getThresholdValue());
75	<	message = StringUtils.replaceText(message, "%attributeName%", alert.getAttributeName());
76	<
66	>	// sort out the message
67	>	String alertType = Alert.alertLevels[alert.getLevel()];
68	>	String message;
69	>	try {
70	>	message = _cp.getProperty(_name, "Alerter.IRC.message");
71	>	} catch (PropertyNotFoundException e) {
72	>	message = NOT_CONFIGURED;
73	>	_logger.write(toString(), Logger.WARNING, "Alerter.IRC.message value unavailable using default of " + message);
74	>	}
75	>	message = processAlertMessage(message, alert);
76	>	// only send alerts if we're active
77	>	if(_active) {
78		// send the message
79	<	_logger.write(toString(), Logger.DEBUG, "Sending IRC Alert at level"+String.valueOf(alert.getLevel()));
79	>	_logger.write(toString(), Logger.DEBUG, "Sending " + _name + " at "+ alertType + " level");
80		_ircbot.sendMsg(message);
81	+	// count sent alerts
82	+	_alertCount++;
83	+	} else {
84	+	// don't send, but keep a count that we ignored it
85	+	_ignoredCount++;
86		}
87	+	// we'll always store the "last alert", regardless
88	+	// of whether we actually display it or not
89	+	_lastAlert = message;
90	+	_lastAlertTime = System.currentTimeMillis();
91		}
92
93		/**
94		* Overrides the {@link java.lang.Object#toString() Object.toString()}
95		* method to provide clean logging (every class should have this).
96		*
97	<	* This uses the uk.ac.ukc.iscream.util.NameFormat class
97	>	* This uses the uk.org.iscream.cms.server.util.NameFormat class
98		* to format the toString()
99		*
100		* @return the name of this class and its CVS revision
#	Line 97 | Line 106 | public class IRC__Alerter implements PluginAlerter {
106		REVISION);
107		}
108
109	<	/**
110	<	* return the String representation of what the filter does
109	>	/**
110	>	* Return the String representation of what the alerter does
111	>	*
112	>	* @return the description
113		*/
114		public String getDescription(){
115		return DESC;
#	Line 108 | Line 119 | public class IRC__Alerter implements PluginAlerter {
119
120		//---ACCESSOR/MUTATOR METHODS---
121
122	<	//---ATTRIBUTES---
122	>	/**
123	>	* Returns the "friendly" name of this class. This
124	>	* is simply an accessor for _name, required due to
125	>	* inheritance issues with extending AlerterSkeleton.
126	>	*
127	>	* @return the friendly name
128	>	*/
129	>	protected String getFName() {
130	>	return _name;
131	>	}
132
133	<	// an integer value
114	<	private int _level;
133	>	//---ATTRIBUTES---
134
135	<	// the hostname of the IRC server
136	<	private String _IRCServer;
135	>	/**
136	>	* A reference to the IRCBot
137	>	*/
138	>	private IRCBot _ircbot;
139
140	<	// the port number of the IRC server
141	<	private int _IRCPort;
140	>	/**
141	>	* Are we "active"
142	>	*/
143	>	private boolean _active = false;
144
145	<	// the nickname to use
146	<	private String _nick;
145	>	/**
146	>	* The last alert that was sent
147	>	*/
148	>	private String _lastAlert = "no alerts have been sent";
149
150	<	// the channel to join
151	<	private String _channel;
150	>	/**
151	>	* The time of the last alert
152	>	*/
153	>	private long _lastAlertTime = -1;
154
155	<	// the ircbot
156	<	private IRCBot _ircbot;
155	>	/**
156	>	* Number of alerts sent
157	>	*/
158	>	private int _alertCount = 0;
159
160	<	// a message with the following: %level% and %message%
161	<	private String _message;
160	>	/**
161	>	* Number of alerts ignored when in "stopped" mode
162	>	*/
163	>	private int _ignoredCount = 0;
164
165		/**
166	+	* Time of IRCBot startup
167	+	*/
168	+	private long _startTime;
169	+
170	+	/**
171	+	* This holds a reference to the
172	+	* system logger that is being used.
173	+	*/
174	+	protected Logger _logger = ReferenceManager.getInstance().getLogger();
175	+
176	+	/**
177		* This is the friendly identifier of the
178		* component this class is running in.
179		* eg, a Filter may be called "filter1",
#	Line 140 | Line 182 | public class IRC__Alerter implements PluginAlerter {
182		* can be placed here.  This name could also
183		* be changed to null for utility classes.
184		*/
185	<	private String _name = ClientMain.NAME;
185	>	private String _name = "IRC";
186
145	–	/**
146	–	* This holds a reference to the
147	–	* system logger that is being used.
148	–	*/
149	–	private Logger _logger = ReferenceManager.getInstance().getLogger();
150	–
187		//---STATIC ATTRIBUTES---
188
189		//---INNER CLASSES---
190
191	<	/**
156	<	* This class provides some basic IRCBot functionality. It connects
157	<	* to a specified server, and will remain there until told to
158	<	* leave. Whilst connected it can send a message or a notice to
159	<	* the server.
160	<	*/
161	<	class IRCBot extends Thread {
191	>	class IRCBot extends PircBot implements Runnable {
192
193		/**
194	<	* Main thread loop, this part of the class listens for
165	<	* messages from the server, and acts accordingly. At the
166	<	* present moment it only responds to pings.
194	>	* The default reconnect delay in seconds
195		*/
196	+	public final int DEFAULT_RECONNECT_DELAY = 30;
197	+
198		public void run() {
199	<	// flag so we can stop the loop
170	<	boolean run = true;
171	<	while(run) {
199	>	while(true) {
200		try {
201	<	// read a command
202	<	String cmd = _socketIn.readLine();
175	<	// if it's a PING...
176	<	if(cmd.startsWith("PING")) {
177	<	// ...send a PONG
178	<	_socketOut.println("PONG" + cmd.substring(4));
179	<	}
180	<	} catch (IOException e) {
181	<	// comms failure, lets stop
182	<	_logger.write(this.toString(), Logger.ERROR, "Comms error: "+e);
183	<	//run = false;
201	>	init();
202	>	break;
203		}
204	+	catch (IOException e) {
205	+	_logger.write(this.toString(), Logger.ERROR, "Error initialising IRCBot: "+e);
206	+	reconnectSleep();
207	+	}
208		}
209	+	//System.out.println("falling out!");
210		}
211
212	<	/**
213	<	* Sends a message to the channel.
214	<	*
215	<	* @param msg The message to send
216	<	*/
212	>	public void init() throws IOException {
213	>	_logger.write(this.toString(), Logger.DEBUG, "Initialising IRCBot...");
214	>	ConfigurationProxy cp = ConfigurationProxy.getInstance();
215	>	String server;
216	>	int port;
217	>	try {
218	>	server = cp.getProperty(_name, "Alerter.IRC.IRCServer");
219	>	port = Integer.parseInt(cp.getProperty(_name, "Alerter.IRC.IRCPort"));
220	>	} catch (PropertyNotFoundException e) {
221	>	_logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
222	>	throw new IOException("Can't get irc server details due to configuration error");
223	>	} catch (NumberFormatException e) {
224	>	_logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
225	>	throw new IOException("Can't get irc server details due to malformed configuration");
226	>	}
227	>	String user, comment;
228	>	try {
229	>	user = cp.getProperty(_name, "Alerter.IRC.user");
230	>	comment = cp.getProperty(_name, "Alerter.IRC.comment");
231	>	} catch (PropertyNotFoundException e) {
232	>	_logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
233	>	throw new IOException("Can't get user details due to configuration error");
234	>	}
235	>	this.setLogin(user);
236	>	this.setVersion(comment);
237	>	this.setFinger(comment); // ?
238	>	String nickList;
239	>	try {
240	>	nickList = cp.getProperty(_name, "Alerter.IRC.nickList");
241	>	} catch (PropertyNotFoundException e) {
242	>	_logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
243	>	throw new IOException("Can't get nickname due to configuration error");
244	>	}
245	>	StringTokenizer st = new StringTokenizer(nickList, ";");
246	>	boolean ok = false;
247	>	while(!ok && st.hasMoreTokens()) {
248	>	String nick = st.nextToken();
249	>	try {
250	>	_logger.write(this.toString(), Logger.DEBUG, "Trying nick: "+nick);
251	>	this.setName(nick);
252	>	this.connect(server, port);
253	>	// must be ok if we get here
254	>	_nickname = nick;
255	>	ok = true;
256	>	}
257	>	catch(IOException e) {
258	>	_logger.write(this.toString(), Logger.ERROR, "IO error when connecting to server: "+e);
259	>	throw new IOException("IO error when connecting to server");
260	>	}
261	>	catch(IrcException e) {
262	>	_logger.write(this.toString(), Logger.ERROR, "IRC error when connecting to server: "+e);
263	>	throw new IOException("IRC error when connecting to server");
264	>	}
265	>	catch(NickAlreadyInUseException e) {
266	>	_logger.write(this.toString(), Logger.ERROR, "Nickname "+nick+" is already in use: "+e);
267	>	// just carry on around while loop
268	>	}
269	>	}
270	>	if(!ok) {
271	>	// oh dear, we couldn't get on.
272	>	_logger.write(this.toString(), Logger.ERROR, "All nicknames already in use");
273	>	throw new IOException("All nicknames already in use");
274	>	}
275	>	try {
276	>	_channel = cp.getProperty(_name, "Alerter.IRC.channel");
277	>	this.joinChannel(_channel);
278	>	} catch (PropertyNotFoundException e) {
279	>	_logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
280	>	throw new IOException("Can't get channel name due to configuration error");
281	>	}
282	>
283	>	String startupNotice;
284	>	try {
285	>	startupNotice = ConfigurationProxy.getInstance().getProperty(_name, "Alerter.IRC.startupNotice");
286	>	sendNotice(_channel, startupNotice);
287	>	} catch (PropertyNotFoundException e) {
288	>	_logger.write(this.toString(), Logger.DEBUG, "Startup notice not defined, so not sending: "+e);
289	>	}
290	>
291	>	// we should set this when all is ready!
292	>	_active = true;
293	>	//System.out.println("leaving init");
294	>	}
295	>
296		public void sendMsg(String msg) {
297	<	_socketOut.println("PRIVMSG "+_channel+" :"+msg);
297	>	sendMessage(_channel, msg);
298		}
299
300	<	/**
301	<	* Sends a notice to the channel.
302	<	*
303	<	* @param msg The notice to send
304	<	*/
305	<	public void sendNotice(String msg) {
306	<	_socketOut.println("NOTICE "+_channel+" :"+msg);
300	>	public void onDisconnect() {
301	>	_active = false;
302	>	while(true) {
303	>	reconnectSleep();
304	>	try {
305	>	init();
306	>	break;
307	>	}
308	>	catch (IOException e) {
309	>	_logger.write(this.toString(), Logger.ERROR, "Error initialising IRCBot: "+e);
310	>	}
311	>	}
312	>	//System.out.println("falling out of disconnect!");
313		}
314
315	<	/**
316	<	* Connect to the IRC server, log in, and join the channel.
317	<	*
318	<	* @throws IOException if the connection fails
319	<	*/
320	<	public void connect() throws IOException {
321	<	// setup the socket, reader and writer
213	<	_socket = new Socket(_IRCServer, _IRCPort);
214	<	_socketIn = new BufferedReader(new InputStreamReader(_socket.getInputStream()));
215	<	_socketOut = new PrintWriter(_socket.getOutputStream(), true);
216	<	// send the various log in messages
217	<	_socketOut.println("PASS");
218	<	_socketOut.println("NICK "+_nick);
219	<	_socketOut.println("USER iscream 8 * :i-scream Bot");
220	<	// join the channel
221	<	_socketOut.println("JOIN "+_channel);
222	<	// start our listening thread
223	<	this.start();
315	>	public void onMessage(String channel, String sender, String login, String hostname, String message) {
316	>	if(isForMe(message)) {
317	>	String response = handleInput(message);
318	>	if(response != null) {
319	>	sendMessage(channel, response);
320	>	}
321	>	}
322		}
323
324	+	public void onPrivateMessage(String sender, String login, String hostname, String message) {
325	+	String response = handleInput(message);
326	+	if(response != null) {
327	+	sendMessage(sender, response);
328	+	}
329	+	}
330	+
331	+	public void onNickChange(String oldNick, String login, String hostname, String newNick) {
332	+	if(oldNick.equals(_nickname)) {
333	+	_nickname = newNick;
334	+	}
335	+	}
336	+
337	+	private String handleInput(String message) {
338	+	//return "yup, gotcha!";
339	+	ConfigurationProxy cp = ConfigurationProxy.getInstance();
340	+	// setup some String's
341	+	String stopCommand, startCommand, timeSinceLastAlertCommand, lastAlertCommand, joinCommand;
342	+	String nickChangeCommand, versionCommand, helpCommand, statCommand, uptimeCommand;
343	+	// get the command set
344	+	try {
345	+	stopCommand = cp.getProperty(_name, "Alerter.IRC.stopCommand");
346	+	startCommand = cp.getProperty(_name, "Alerter.IRC.startCommand");
347	+	timeSinceLastAlertCommand = cp.getProperty(_name, "Alerter.IRC.timeSinceLastAlertCommand");
348	+	lastAlertCommand = cp.getProperty(_name, "Alerter.IRC.lastAlertCommand");
349	+	joinCommand = cp.getProperty(_name, "Alerter.IRC.joinCommand");
350	+	nickChangeCommand = cp.getProperty(_name, "Alerter.IRC.nickChangeCommand");
351	+	versionCommand = cp.getProperty(_name, "Alerter.IRC.versionCommand");
352	+	helpCommand = cp.getProperty(_name, "Alerter.IRC.helpCommand");
353	+	statCommand = cp.getProperty(_name, "Alerter.IRC.statCommand");
354	+	uptimeCommand = cp.getProperty(_name, "Alerter.IRC.uptimeCommand");
355	+	} catch (PropertyNotFoundException e) {
356	+	_logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
357	+	// lets bail from handling this line...
358	+	// ...it's gonna be hard without a command set!
359	+	return null;
360	+	}
361	+
362	+	if(message.indexOf(stopCommand)!=-1) {
363	+	_active = false;
364	+	return "alerts have been stopped";
365	+	}
366	+	else if(message.indexOf(startCommand)!=-1) {
367	+	_active = true;
368	+	return "alerts have been activated";
369	+	}
370	+	// this needs to go here if it contains the same words as the lastAlertCommand
371	+	else if(message.indexOf(timeSinceLastAlertCommand)!=-1) {
372	+	if(_lastAlertTime != -1) {
373	+	long uptime = (System.currentTimeMillis() - _lastAlertTime) / 1000;
374	+	String uptimeText = DateUtils.formatTime(uptime, "%DAYS% days, %HOURS% hours, %MINS% mins, and %SECS% secs");
375	+	return "I last sent an alert "+uptimeText+ " ago";
376	+	}
377	+	else {
378	+	return "I've never sent an alert!";
379	+	}
380	+	}
381	+	else if(message.indexOf(lastAlertCommand)!=-1) {
382	+	if(_lastAlertTime != -1) {
383	+	String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, Locale.UK).format(new Date(_lastAlertTime));
384	+	return "last alert was at "+date+"; "+_lastAlert;
385	+	}
386	+	else {
387	+	return "I've never sent an alert!";
388	+	}
389	+
390	+	}
391	+	else if(message.indexOf(joinCommand)!=-1) {
392	+	String joinCmd = joinCommand;
393	+	String newChan = message.substring(message.indexOf(joinCmd) + joinCmd.length() + 1);
394	+	int endOfChan = newChan.indexOf(" ");
395	+	if(endOfChan == -1) {
396	+	endOfChan = newChan.length();
397	+	}
398	+	newChan = newChan.substring(0, endOfChan);
399	+	if(newChan.equals(_channel)) {
400	+	return "I'm already on "+newChan+"!";
401	+	} else {
402	+	partChannel(_channel);
403	+	joinChannel(newChan);
404	+	_channel = newChan;
405	+	return null; // ???
406	+	}
407	+	}
408	+	else if(message.indexOf(nickChangeCommand)!=-1) {
409	+	String nickChangeCmd = nickChangeCommand;
410	+	String newNick = message.substring(message.indexOf(nickChangeCmd) + nickChangeCmd.length() + 1);
411	+	int endOfNick = newNick.indexOf(" ");
412	+	if(endOfNick == -1) {
413	+	endOfNick = newNick.length();
414	+	}
415	+	newNick = newNick.substring(0, endOfNick);
416	+	changeNick(newNick);
417	+	// should we check this worked?
418	+	//_nickname = newNick;
419	+	return null; // ???
420	+	}
421	+	else if(message.indexOf(versionCommand)!=-1) {
422	+	return "I am version "+REVISION.substring(11, REVISION.length() -2)+" of the i-scream alerting bot";
423	+	}
424	+	else if(message.indexOf(helpCommand)!=-1) {
425	+	return "this will return some help text soon";
426	+	/*
427	+	sendPrivMsg(getMsgSender(line), "Hello, I am the i-scream alerting bot version "+REVISION.substring(11, REVISION.length() -2));
428	+	sendPrivMsg(getMsgSender(line), "I understand the following commands;");
429	+	sendPrivMsg(getMsgSender(line), stopCommand);
430	+	sendPrivMsg(getMsgSender(line), startCommand);
431	+	sendPrivMsg(getMsgSender(line), lastAlertCommand);
432	+	sendPrivMsg(getMsgSender(line), joinCommand);
433	+	sendPrivMsg(getMsgSender(line), nickChangeCommand);
434	+	sendPrivMsg(getMsgSender(line), statCommand);
435	+	sendPrivMsg(getMsgSender(line), uptimeCommand);
436	+	sendPrivMsg(getMsgSender(line), timeSinceLastAlertCommand);
437	+	sendPrivMsg(getMsgSender(line), helpCommand);
438	+	*/
439	+	}
440	+	else if(message.indexOf(statCommand)!=-1) {
441	+	return "I have sent a total of "+_alertCount+" alerts, and ignored a total of "+_ignoredCount+"!";
442	+	}
443	+	else if(message.indexOf(uptimeCommand)!=-1) {
444	+	long uptime = (System.currentTimeMillis() - _startTime) / 1000;
445	+	String uptimeText = DateUtils.formatTime(uptime, "%DAYS% days, %HOURS% hours, %MINS% mins, and %SECS% secs");
446	+	return "I have been running for "+uptimeText;
447	+	}
448	+	else if(message.indexOf("ping")!=-1) {
449	+	return "pong";
450	+	}
451	+	else if(message.indexOf("do a jibble dance")!=-1) {
452	+	// little joke :)
453	+	return "jives to the funky beat shouting \"ii--screeeaaammm\"";
454	+	}
455	+
456	+	else {
457	+	String rejectMessage = NOT_CONFIGURED;
458	+	try {
459	+	rejectMessage = cp.getProperty(_name, "Alerter.IRC.rejectMessage");
460	+	} catch(PropertyNotFoundException e) {
461	+	_logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
462	+	}
463	+	return rejectMessage;
464	+	}
465	+	}
466	+
467	+	private boolean isForMe(String message) {
468	+	// change this!
469	+	String nick = _nickname.toLowerCase();
470	+	String msg = message.toLowerCase();
471	+	if(msg.startsWith(nick + ", ") ||
472	+	msg.startsWith(nick + ": ") ||
473	+	msg.startsWith(nick + " ")) {
474	+	return true;
475	+	}
476	+	else {
477	+	return false;
478	+	}
479	+	}
480	+
481	+	private void reconnectSleep() {
482	+	int delayTime = 0;
483	+	try {
484	+	delayTime = Integer.parseInt(ConfigurationProxy.getInstance().getProperty(_name, "Alerter.IRC.reconnectDelay"));
485	+	} catch (NumberFormatException e) {
486	+	delayTime = DEFAULT_RECONNECT_DELAY;
487	+	_logger.write(this.toString(), Logger.WARNING, "Erronous Alerter.IRC.reconnectDelay value in configuration using default of " + delayTime + " seconds");
488	+	} catch (PropertyNotFoundException e) {
489	+	delayTime = DEFAULT_RECONNECT_DELAY;
490	+	_logger.write(this.toString(), Logger.WARNING, "Alerter.IRC.reconnectDelay value unavailable using default of " + delayTime + " seconds");
491	+	}
492	+	_logger.write(this.toString(), Logger.ERROR, "Waiting "+delayTime+" seconds for reconnect...");
493	+	try {
494	+	Thread.sleep(delayTime * 1000);
495	+	} catch (InterruptedException e) {}
496	+	}
497	+
498		/**
499	<	* Disconnect "nicely" from the IRC server.
499	>	* Overrides the {@link java.lang.Object#toString() Object.toString()}
500	>	* method to provide clean logging (every class should have this).
501		*
502	<	* @throws IOException if the disconnection fails
502	>	* This uses the uk.org.iscream.cms.server.util.NameFormat class
503	>	* to format the toString()
504	>	*
505	>	* @return the name of this class and its CVS revision
506		*/
507	<	public void disconnect() throws IOException {
508	<	// send proper QUIT
509	<	_socketOut.println("QUIT : iscreamBot component shutting down...");
510	<	// close the socket
511	<	_socketOut.close();
236	<	_socketIn.close();
237	<	_socket.close();
507	>	public String toString() {
508	>	return FormatName.getName(
509	>	_name,
510	>	getClass().getName(),
511	>	REVISION);
512		}
239	–
240	–	/**
241	–	* The socket connected to the server
242	–	*/
243	–	private Socket _socket;
513
514		/**
515	<	* The writer
515	>	* Just a reminder to what channel we're on...
516	>	* this can't be dynamic :)
517		*/
518	<	private PrintWriter _socketOut;
518	>	private String _channel;
519
520		/**
521	<	* The reader
521	>	* A reminder of our current nickname...
522		*/
523	<	private BufferedReader _socketIn;
523	>	private String _nickname;
524
525		}
526

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines