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.30 by tdb, Thu Jan 17 17:58:12 2002 UTC vs.
Revision 1.30.2.1 by tdb, Mon Feb 4 00:14:13 2002 UTC

#	Line 10 | Line 10 | 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.
#	Line 34 | Line 35 | public class IRC__Alerter extends AlerterSkeleton {
35		*/
36		public final String DESC = "Sends alerts on an IRC channel";
37
37	–	/**
38	–	* The default reconnect delay in seconds
39	–	*/
40	–	public final int DEFAULT_RECONNECT_DELAY = 30;
41	–
38		//---STATIC METHODS---
39
40		//---CONSTRUCTORS---
41	<
41	>
42		public IRC__Alerter() {
43		super();
44	<	// connect to the IRC server
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	<	_ircbot.setName("client.IRC__Alerter$IRCBot");
50	<	_ircbot.start();
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		}
#	Line 169 | Line 168 | public class IRC__Alerter extends AlerterSkeleton {
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 183 | Line 188 | public class IRC__Alerter extends AlerterSkeleton {
188
189		//---INNER CLASSES---
190
191	<	/**
187	<	* This class provides some basic IRCBot functionality. It connects
188	<	* to a specified server, and will remain there until told to
189	<	* leave. Whilst connected it can send a message or a notice to
190	<	* the server.
191	<	*/
192	<	class IRCBot extends Thread {
191	>	class IRCBot extends PircBot implements Runnable {
192
194	–	public static final String DEFAULT_STARTUP_NOTICE = "i-scream ircbot starting...";
195	–
193		/**
194	<	* Main thread loop, this part of the class listens for
198	<	* messages from the server, and acts accordingly. At the
199	<	* 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	<	// so we can stop if required
203	<	boolean run = true;
204	<	while(run) {
205	<	// flag so we can stop the loop
206	<	boolean doRead = true;
207	<	// get the startup notice
208	<	String startupNotice;
199	>	while(true) {
200		try {
201	<	startupNotice = ConfigurationProxy.getInstance().getProperty(_name, "Alerter.IRC.startupNotice");
202	<	} catch (PropertyNotFoundException e) {
212	<	startupNotice = DEFAULT_STARTUP_NOTICE;
213	<	_logger.write(this.toString(), Logger.WARNING, "Configuration error: "+e);
201	>	init();
202	>	break;
203		}
204	<	// connect to the IRC server
205	<	try {
206	<	connect();
218	<	sendNotice(startupNotice);
219	<	} catch(IOException e) {
220	<	doRead=false;
221	<	_logger.write(this.toString(), Logger.ERROR, "Error connecting: "+e);
204	>	catch (IOException e) {
205	>	_logger.write(this.toString(), Logger.ERROR, "Error initialising IRCBot: "+e);
206	>	reconnectSleep();
207		}
223	–	while(doRead) {
224	–	try {
225	–	// read a command
226	–	String cmd = _socketIn.readLine();
227	–	// if we have a null, we've lost contact
228	–	if(cmd == null) {
229	–	throw new IOException("End of stream reached");
230	–	}
231	–	// let another method deal with the input
232	–	handleInput(cmd);
233	–	} catch (IOException e) {
234	–	// comms failure, maybe our link is dead.
235	–	_logger.write(this.toString(), Logger.ERROR, "Communication error: "+e);
236	–	// stop, and loop round for a reconnect.
237	–	doRead = false;
238	–	}
239	–	}
240	–	// make sure we're disconnected
241	–	try {
242	–	disconnect();
243	–	} catch (IOException e) {
244	–	_logger.write(this.toString(), Logger.ERROR, "Communication error: "+e);
245	–	}
246	–
247	–	// comms have failed, so wait a while and reconnect
248	–	int delayTime = 0;
249	–	try {
250	–	delayTime = Integer.parseInt(ConfigurationProxy.getInstance().getProperty(_name, "Alerter.IRC.reconnectDelay"));
251	–	} catch (NumberFormatException e) {
252	–	delayTime = DEFAULT_RECONNECT_DELAY;
253	–	_logger.write(this.toString(), Logger.WARNING, "Erronous Alerter.IRC.reconnectDelay value in configuration using default of " + delayTime + " seconds");
254	–	} catch (PropertyNotFoundException e) {
255	–	delayTime = DEFAULT_RECONNECT_DELAY;
256	–	_logger.write(this.toString(), Logger.WARNING, "Alerter.IRC.reconnectDelay value unavailable using default of " + delayTime + " seconds");
257	–	}
258	–	try {
259	–	Thread.sleep(delayTime * 1000);
260	–	} catch (InterruptedException e) {}
208		}
209	<	// maybe disconnect here ? - shutdown method not implemented yet
263	<	//disconnect();
209	>	//System.out.println("falling out!");
210		}
211
212	<	/**
213	<	* Sends a message to the channel.
268	<	*
269	<	* @param msg The message to send
270	<	*/
271	<	public void sendMsg(String msg) {
272	<	_socketOut.println("PRIVMSG "+_channel+" :"+msg);
273	<	// wait a second before returning...
274	<	// this ensures messages can't be sent too fast
275	<	try {Thread.sleep(1000);} catch (InterruptedException e) {}
276	<	}
277	<
278	<	/**
279	<	* Sends a message to the channel.
280	<	*
281	<	* @param user The user to send to
282	<	* @param msg The message to send
283	<	*/
284	<	public void sendPrivMsg(String user, String msg) {
285	<	_socketOut.println("PRIVMSG "+user+" :"+msg);
286	<	// wait a second before returning...
287	<	// this ensures messages can't be sent too fast
288	<	try {Thread.sleep(1000);} catch (InterruptedException e) {}
289	<	}
290	<
291	<	/**
292	<	* Sends an action to the channel.
293	<	*
294	<	* @param msg the action message
295	<	*/
296	<	public void sendAction(String msg) {
297	<	char esc = 001;
298	<	sendMsg(esc+"ACTION "+msg+esc);
299	<	// wait a second before returning...
300	<	// this ensures messages can't be sent too fast
301	<	try {Thread.sleep(1000);} catch (InterruptedException e) {}
302	<	}
303	<
304	<	/**
305	<	* Sends a notice to the channel.
306	<	*
307	<	* @param msg The notice to send
308	<	*/
309	<	public void sendNotice(String msg) {
310	<	_socketOut.println("NOTICE "+_channel+" :"+msg);
311	<	// wait a second before returning...
312	<	// this ensures messages can't be sent too fast
313	<	try {Thread.sleep(1000);} catch (InterruptedException e) {}
314	<	}
315	<
316	<	/**
317	<	* Connect to the IRC server, log in, and join the channel.
318	<	*
319	<	* @throws IOException if the connection fails
320	<	*/
321	<	public void connect() throws IOException {
212	>	public void init() throws IOException {
213	>	_logger.write(this.toString(), Logger.DEBUG, "Initialising IRCBot...");
214		ConfigurationProxy cp = ConfigurationProxy.getInstance();
323	–	// setup the socket, reader and writer
215		String server;
216		int port;
217		try {
#	Line 333 | Line 224 | public class IRC__Alerter extends AlerterSkeleton {
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		}
336	–	_socket = new Socket(server, port);
337	–	_socketIn = new BufferedReader(new InputStreamReader(_socket.getInputStream()));
338	–	_socketOut = new PrintWriter(_socket.getOutputStream(), true);
339	–	//_socketOut.println("PASS");
340	–	// send USER details
227		String user, comment;
228		try {
229		user = cp.getProperty(_name, "Alerter.IRC.user");
#	Line 346 | Line 232 | public class IRC__Alerter extends AlerterSkeleton {
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	<	_socketOut.println("USER "+user+" 8 * :"+comment);
236	<	// attempt to get a nick
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");
#	Line 357 | Line 244 | public class IRC__Alerter extends AlerterSkeleton {
244		}
245		StringTokenizer st = new StringTokenizer(nickList, ";");
246		boolean ok = false;
360	–	// try until we exhaust our list
247		while(!ok && st.hasMoreTokens()) {
248		String nick = st.nextToken();
249	<	_socketOut.println("NICK "+nick);
250	<	// get a "yes" or "no" response back
251	<	String response = "";
252	<	do {
253	<	response = _socketIn.readLine();
368	<	if(response==null) {
369	<	throw new IOException("Communication error whilst logging in");
370	<	}
371	<	} while(response.indexOf("001")==-1 && response.indexOf("433")==-1);
372	<	// see if it was a yes
373	<	if(response.indexOf("001")!=-1) {
374	<	// great, we're logged in !
375	<	ok = true;
376	<	// store the name we're using
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	<	else {
258	<	// log we couldn't get the name
259	<	_logger.write(this.toString(), Logger.WARNING, "Nickname in use: "+nick);
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	<	throw new IOException("All nicknames in use");
272	>	_logger.write(this.toString(), Logger.ERROR, "All nicknames already in use");
273	>	throw new IOException("All nicknames already in use");
274		}
388	–	// join the channel
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	<	_socketOut.println("JOIN "+_channel);
283	<	// allow alerts
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	<	/**
297	<	* Disconnect "nicely" from the IRC server.
298	<	*
299	<	* @throws IOException if the disconnection fails
300	<	*/
405	<	public void disconnect() throws IOException {
406	<	// stop alerts
296	>	public void sendMsg(String msg) {
297	>	sendMessage(_channel, msg);
298	>	}
299	>
300	>	public void onDisconnect() {
301		_active = false;
302	<	// send proper QUIT
303	<	_socketOut.println("QUIT : iscreamBot component shutting down...");
304	<	// close the socket
305	<	_socketOut.close();
306	<	_socketIn.close();
307	<	_socket.close();
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	<	* Overrides the {@link java.lang.Object#toString() Object.toString()}
317	<	* method to provide clean logging (every class should have this).
318	<	*
319	<	* This uses the uk.org.iscream.cms.server.util.NameFormat class
320	<	* to format the toString()
321	<	*
423	<	* @return the name of this class and its CVS revision
424	<	*/
425	<	public String toString() {
426	<	return FormatName.getName(
427	<	_name,
428	<	getClass().getName(),
429	<	REVISION);
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	<	/**
325	<	* Deals with incoming lines from the server.
326	<	*
327	<	* @param line the line to deal with
328	<	*/
329	<	private void handleInput(String line) {
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	<	// if it's a PING...
341	<	if(line.startsWith("PING")) {
342	<	// ...send a PONG
343	<	_socketOut.println("PONG" + line.substring(4));
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	<	// see if it's for us
362	<	else if(getMsg(line).toLowerCase().startsWith(_nickname.toLowerCase()+",") ||
363	<	getMsg(line).toLowerCase().startsWith(_nickname.toLowerCase()+":") ||
364	<	getMsg(line).toLowerCase().startsWith(_nickname.toLowerCase()+" ")) {
365	<	// setup some String's
366	<	String stopCommand, startCommand, timeSinceLastAlertCommand, lastAlertCommand, joinCommand;
367	<	String nickChangeCommand, versionCommand, helpCommand, statCommand, uptimeCommand;
368	<	// get the command set
369	<	try {
370	<	stopCommand = cp.getProperty(_name, "Alerter.IRC.stopCommand");
371	<	startCommand = cp.getProperty(_name, "Alerter.IRC.startCommand");
372	<	timeSinceLastAlertCommand = cp.getProperty(_name, "Alerter.IRC.timeSinceLastAlertCommand");
373	<	lastAlertCommand = cp.getProperty(_name, "Alerter.IRC.lastAlertCommand");
374	<	joinCommand = cp.getProperty(_name, "Alerter.IRC.joinCommand");
375	<	nickChangeCommand = cp.getProperty(_name, "Alerter.IRC.nickChangeCommand");
459	<	versionCommand = cp.getProperty(_name, "Alerter.IRC.versionCommand");
460	<	helpCommand = cp.getProperty(_name, "Alerter.IRC.helpCommand");
461	<	statCommand = cp.getProperty(_name, "Alerter.IRC.statCommand");
462	<	uptimeCommand = cp.getProperty(_name, "Alerter.IRC.uptimeCommand");
463	<	} catch (PropertyNotFoundException e) {
464	<	_logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
465	<	// lets bail from handling this line...
466	<	// ...it's gonna be hard without a command set!
467	<	return;
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	<
378	<	// we have a message for us
471	<	String message = getMsg(line).substring(_nickname.length());
472	<	if(message.indexOf(stopCommand)!=-1) {
473	<	_active = false;
474	<	sendMsg(getMsgSender(line)+", alerts have been stopped");
377	>	else {
378	>	return "I've never sent an alert!";
379		}
380	<	else if(message.indexOf(startCommand)!=-1) {
381	<	_active = true;
382	<	sendMsg(getMsgSender(line)+", alerts have been activated");
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	<	// this needs to go here if it contains the same words as the lastAlertCommand
387	<	else if(message.indexOf(timeSinceLastAlertCommand)!=-1) {
482	<	if(_lastAlertTime != -1) {
483	<	long uptime = (System.currentTimeMillis() - _lastAlertTime) / 1000;
484	<	String uptimeText = DateUtils.formatTime(uptime, "%DAYS% days, %HOURS% hours, %MINS% mins, and %SECS% secs");
485	<	sendMsg(getMsgSender(line)+", I last sent an alert "+uptimeText+ " ago");
486	<	}
487	<	else {
488	<	sendMsg(getMsgSender(line)+", I've never sent an alert!");
489	<	}
386	>	else {
387	>	return "I've never sent an alert!";
388		}
389	<	else if(message.indexOf(lastAlertCommand)!=-1) {
390	<	if(_lastAlertTime != -1) {
391	<	String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, Locale.UK).format(new Date(_lastAlertTime));
392	<	sendMsg(getMsgSender(line)+", last alert was at "+date+"; "+_lastAlert);
393	<	}
394	<	else {
395	<	sendMsg(getMsgSender(line)+", I've never sent an alert!");
396	<	}
499	<
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	<	else if(message.indexOf(joinCommand)!=-1) {
399	<	String joinCmd = joinCommand;
400	<	String newChan = message.substring(message.indexOf(joinCmd) + joinCmd.length() + 1);
401	<	int endOfChan = newChan.indexOf(" ");
402	<	if(endOfChan == -1) {
403	<	endOfChan = newChan.length();
404	<	}
405	<	newChan = newChan.substring(0, endOfChan);
509	<	if(newChan.equals(_channel)) {
510	<	sendMsg(getMsgSender(line)+", I'm already on "+newChan+"!");
511	<	} else {
512	<	sendMsg(getMsgSender(line)+", okay, I'm off to "+newChan);
513	<	_socketOut.println("PART "+_channel);
514	<	_socketOut.println("JOIN "+newChan);
515	<	_channel = newChan;
516	<	}
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	<	else if(message.indexOf(nickChangeCommand)!=-1) {
408	<	String nickChangeCmd = nickChangeCommand;
409	<	String newNick = message.substring(message.indexOf(nickChangeCmd) + nickChangeCmd.length() + 1);
410	<	int endOfNick = newNick.indexOf(" ");
411	<	if(endOfNick == -1) {
412	<	endOfNick = newNick.length();
413	<	}
525	<	newNick = newNick.substring(0, endOfNick);
526	<	sendMsg(getMsgSender(line)+", okay, changing my nickname to "+newNick);
527	<	_socketOut.println("NICK "+newNick);
528	<	_nickname = newNick;
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	<	else if(message.indexOf(versionCommand)!=-1) {
416	<	sendMsg(getMsgSender(line)+", I am version "+REVISION.substring(11, REVISION.length() -2)+" of the i-scream alerting bot");
417	<	}
418	<	else if(message.indexOf(helpCommand)!=-1) {
419	<	sendPrivMsg(getMsgSender(line), "Hello, I am the i-scream alerting bot version "+REVISION.substring(11, REVISION.length() -2));
535	<	sendPrivMsg(getMsgSender(line), "I understand the following commands;");
536	<	sendPrivMsg(getMsgSender(line), stopCommand);
537	<	sendPrivMsg(getMsgSender(line), startCommand);
538	<	sendPrivMsg(getMsgSender(line), lastAlertCommand);
539	<	sendPrivMsg(getMsgSender(line), joinCommand);
540	<	sendPrivMsg(getMsgSender(line), nickChangeCommand);
541	<	sendPrivMsg(getMsgSender(line), statCommand);
542	<	sendPrivMsg(getMsgSender(line), uptimeCommand);
543	<	sendPrivMsg(getMsgSender(line), timeSinceLastAlertCommand);
544	<	sendPrivMsg(getMsgSender(line), helpCommand);
545	<	}
546	<	else if(message.indexOf(statCommand)!=-1) {
547	<	sendMsg(getMsgSender(line)+", I have sent a total of "+_alertCount+" alerts, and ignored a total of "+_ignoredCount+"!");
548	<	}
549	<	else if(message.indexOf(uptimeCommand)!=-1) {
550	<	long uptime = (System.currentTimeMillis() - _startTime) / 1000;
551	<	String uptimeText = DateUtils.formatTime(uptime, "%DAYS% days, %HOURS% hours, %MINS% mins, and %SECS% secs");
552	<	sendMsg(getMsgSender(line)+", I have been running for "+uptimeText);
553	<	}
554	<	else if(message.indexOf("ping")!=-1) {
555	<	sendMsg("pong");
556	<	}
557	<	else if(message.indexOf("do a jibble dance")!=-1) {
558	<	// little joke :)
559	<	sendAction("jives to the funky beat shouting \"ii--screeeaaammm\"");
560	<	}
561	<	else {
562	<	String rejectMessage = NOT_CONFIGURED;
563	<	try {
564	<	rejectMessage = cp.getProperty(_name, "Alerter.IRC.rejectMessage");
565	<	} catch(PropertyNotFoundException e) {
566	<	_logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
567	<	}
568	<	sendMsg(getMsgSender(line)+", "+rejectMessage);
569	<	}
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(line.indexOf(_nickname)!=-1 && line.indexOf(_channel)!=-1 && line.indexOf("KICK")!=-1) {
422	<	sendPrivMsg(getMsgSender(line), "That wasn't a nice thing to do...");
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	<	_channel = cp.getProperty(_name, "Alerter.IRC.channel");
459	>	rejectMessage = cp.getProperty(_name, "Alerter.IRC.rejectMessage");
460		} catch(PropertyNotFoundException e) {
461		_logger.write(this.toString(), Logger.ERROR, "Configuration error: "+e);
462		}
463	<	_socketOut.println("JOIN "+_channel);
463	>	return rejectMessage;
464		}
465		}
466
467	<	/**
468	<	* Strips the header from a message line
469	<	*
470	<	* @param line the line to strip
471	<	* @return the message from the line
472	<	*/
473	<	private String getMsg(String line) {
474	<	String result = "";
590	<	if(line.indexOf("PRIVMSG")!=-1) {
591	<	int firstColon = line.indexOf(":");
592	<	if(firstColon != -1) {
593	<	int secondColon = line.indexOf(":", firstColon+1);
594	<	if(secondColon != -1) {
595	<	result = line.substring(secondColon+1);
596	<	}
597	<	}
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	<	return result;
476	>	else {
477	>	return false;
478	>	}
479		}
480
481	<	/**
482	<	* Finds out the sender of the message
483	<	*
484	<	* @param line the line to look for a sender in
485	<	* @return the sender
486	<	*/
487	<	private String getMsgSender(String line) {
488	<	String result = "";
489	<	int colon = line.indexOf(":");
490	<	int excl = line.indexOf("!");
612	<	if(colon!=-1 && excl!=-1) {
613	<	result = line.substring(colon+1, excl);
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	<	return result;
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	<	* The socket connected to the server
499	>	* Overrides the {@link java.lang.Object#toString() Object.toString()}
500	>	* method to provide clean logging (every class should have this).
501	>	*
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	<	private Socket _socket;
507	>	public String toString() {
508	>	return FormatName.getName(
509	>	_name,
510	>	getClass().getName(),
511	>	REVISION);
512	>	}
513
514		/**
624	–	* The writer
625	–	*/
626	–	private PrintWriter _socketOut;
627	–
628	–	/**
629	–	* The reader
630	–	*/
631	–	private BufferedReader _socketIn;
632	–
633	–	/**
515		* Just a reminder to what channel we're on...
516		* this can't be dynamic :)
517		*/
#	Line 640 | Line 521 | public class IRC__Alerter extends AlerterSkeleton {
521		* A reminder of our current nickname...
522		*/
523		private String _nickname;
643	–
644	–	/**
645	–	* This holds a reference to the
646	–	* system logger that is being used.
647	–	*/
648	–	protected Logger _logger = ReferenceManager.getInstance().getLogger();
524
525		}
526

Diff Legend

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