<properties>
<netty.version>4.1.5.Final</netty.version>
<slf4j.version>1.7.21</slf4j.version>
+ <logback.version>1.1.7</logback.version>
</properties>
<dependencies>
<artifactId>netty-all</artifactId>
<version>${netty.version}</version>
</dependency>
-<!-- <dependency>
+ <dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-simple</artifactId>
- <version>${slf4j.version}</version>
- </dependency>-->
+ <groupId>ch.qos.logback</groupId>
+ <artifactId>logback-classic</artifactId>
+ <version>${logback.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>ch.qos.logback</groupId>
+ <artifactId>logback-core</artifactId>
+ <version>${logback.version}</version>
+ </dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
package net.rizon.acid.commands;
-import static net.rizon.acid.core.Acidictive.reply;
-
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
-
import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.AcidUser;
import net.rizon.acid.core.Acidictive;
+import static net.rizon.acid.core.Acidictive.reply;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Command;
-import net.rizon.acid.core.Logger;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.User;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Handles access to acid4 and its plugins.
*/
public class Access extends Command
{
- private static final Logger log = Logger.getLogger(Access.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(Access.class);
public Access()
{
}
catch (SQLException ex)
{
- log.log(ex);
+ log.warn(null, ex);
}
return true;
stmt.setString(2, x.getIdentNick());
Acidictive.acidcore_sql.executeThread(stmt);
}
- catch (Exception e)
+ catch (SQLException e)
{
- log.log(e);
+ log.warn(null, e);
}
reply(x, to, c, "Updated your certfp to \"" + args[1] + "\"");
}
}
catch (SQLException e)
{
- log.log(e);
+ log.warn(null, e);
return;
}
}
catch (SQLException e)
{
- log.log(e);
+ log.warn(null, e);
return;
}
}
catch (SQLException e)
{
- log.log(e);
+ log.warn(null, e);
}
}
}
catch (SQLException e)
{
- log.log(e);
+ log.warn(null, e);
return;
}
}
catch (SQLException e)
{
- log.log(e);
+ log.warn(null, e);
}
}
}
package net.rizon.acid.commands;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.AcidUser;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Command;
import net.rizon.acid.core.Plugin;
import net.rizon.acid.core.User;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Plugins extends Command
{
+ private static final Logger log = LoggerFactory.getLogger(Plugins.class);
+
public Plugins()
{
super(1, 2);
{
p = Plugin.loadPlugin(args[1]);
Acidictive.reply(u, to, c, "Plugin " + p.getName() + " successfully loaded");
- AcidCore.log.log(Level.INFO, "PLUGINS LOAD for " + p.getName() + " from " + u.getNick());
+ log.info("PLUGINS LOAD for " + p.getName() + " from " + u.getNick());
}
catch (Exception ex)
{
- AcidCore.log.log(Level.WARNING, "Unable to load plugin " + args[1], ex);
+ log.warn("Unable to load plugin " + args[1], ex);
Acidictive.reply(u, to, c, "Unable to load plugin " + args[1] + ": " + ex.getMessage());
}
}
p.remove();
Acidictive.reply(u, to, c, "Unloaded plugin " + p.getName());
- AcidCore.log.log(Level.INFO, "PLUGINS UNLOAD for " + p.getName() + " from " + u.getNick());
+ log.info("PLUGINS UNLOAD for " + p.getName() + " from " + u.getNick());
}
else if (args[0].equalsIgnoreCase("RELOAD") && args.length == 2)
{
{
p = Plugin.loadPlugin(args[1]);
Acidictive.reply(u, to, c, "Plugin " + p.getName() + " successfully reloaded");
- AcidCore.log.log(Level.INFO, "PLUGINS RELOAD for " + p.getName() + " from " + u.getNick());
+ log.info("PLUGINS RELOAD for " + p.getName() + " from " + u.getNick());
}
catch (Exception ex)
{
- AcidCore.log.log(Level.WARNING, "Unable to reload plugin " + args[1], ex);
+ log.warn("Unable to reload plugin " + args[1], ex);
Acidictive.reply(u, to, c, "Unable to reload plugin " + args[1] + ": " + ex.getMessage());
}
}
package net.rizon.acid.commands;
-import java.io.IOException;
import java.util.Iterator;
-
import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.AcidUser;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Command;
-import net.rizon.acid.core.Logger;
import net.rizon.acid.core.Protocol;
import net.rizon.acid.core.User;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Shuts acid4 down gracefully.
*/
public class Shutdown extends Command
{
- private static final Logger log = Logger.getLogger(Shutdown.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(Shutdown.class);
public Shutdown()
{
package net.rizon.acid.commands;
-import static net.rizon.acid.core.Acidictive.reply;
import net.rizon.acid.core.AcidUser;
import net.rizon.acid.core.Acidictive;
+import static net.rizon.acid.core.Acidictive.reply;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Command;
import net.rizon.acid.core.Server;
package net.rizon.acid.conf;
import java.util.List;
-
import net.rizon.acid.core.Acidictive;
public class Command implements Validatable
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.List;
-
import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.constructor.CustomClassLoaderConstructor;
import io.netty.channel.socket.nio.NioSocketChannel;
import java.time.Duration;
import java.util.Arrays;
-import java.util.logging.Level;
import net.rizon.acid.io.IRCMessage;
import net.rizon.acid.io.Initializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public abstract class AcidCore
{
- public static final Logger log = Logger.getLogger(AcidCore.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(AcidCore.class);
private static final Duration CONNECT_TIMEOUT = Duration.ofSeconds(5);
}
catch (InterruptedException ex)
{
- log.warning(ex.getMessage());
+ log.warn(null, ex);
}
}
Message m = Message.findMessage(message.getCommand());
if (m == null)
{
- log.log(Level.FINE, "Unknown message " + message.getCommand());
+ log.debug("Unknown message " + message.getCommand());
return;
}
package net.rizon.acid.core;
import java.util.List;
-
import net.rizon.acid.conf.Client;
public class AcidUser extends User
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
-import java.io.IOException;
-import java.net.UnknownHostException;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
-import java.util.logging.Level;
-
import net.rizon.acid.conf.Client;
import net.rizon.acid.conf.Config;
import net.rizon.acid.sql.SQL;
import net.rizon.acid.util.ClassLoader;
import net.rizon.acid.util.CloakGenerator;
import net.rizon.acid.util.Util;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Acidictive extends AcidCore
{
- private static final Logger log = Logger.getLogger(Acidictive.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(Acidictive.class);
+
public static CloakGenerator cloakGenerator;
public static Config conf;
public static long startTime;
{
Version.load();
- log.log(Level.INFO, getVersion() + " (" + Version.getFullVersion() + ") starting up...");
+ log.info(getVersion() + " (" + Version.getFullVersion() + ") starting up...");
try
{
}
catch (Exception ex)
{
- log.log(Level.CONFIG, "Unable to start due to configuration problems", ex);
+ log.error("Unable to start due to configuration problems", ex);
System.exit(1);
}
}
catch (IllegalArgumentException ex)
{
- log.log(Level.SEVERE, ex.getMessage());
+ log.error(null, ex);
System.exit(1);
}
acidcore_sql = SQL.getConnection("acidcore");
if (acidcore_sql == null)
{
- log.log(Level.SEVERE, "Unable to get connection for `acidcore`");
+ log.error("Unable to get connection for `acidcore`");
System.exit(-1);
}
try
{
Plugin p = Plugin.loadPlugin(s);
- log.log(Level.INFO, "Loaded plugin " + p.getName());
+ log.info("Loaded plugin " + p.getName());
}
catch (Exception ex)
{
- log.log(Level.SEVERE, "Unable to load plugin " + s, ex);
+ log.error("Unable to load plugin " + s, ex);
System.exit(-1);
}
}
}
catch (InterruptedException ex)
{
- log.log(Level.SEVERE, null, ex);
+ log.error(null, ex);
}
acidcore_sql.shutdown();
}
catch (SQLException ex)
{
- log.log(Level.WARNING, "Unable to load certfp access", ex);
+ log.warn("Unable to load certfp access", ex);
}
}
}
// Non priv commands can be used by any oper
if (confCommand.privilege == null)
{
- log.log(Level.INFO, "Denied access to " + confCommand.name + " to " + x + " [command has no privilege]");
+ log.info("Denied access to " + confCommand.name + " to " + x + " [command has no privilege]");
// Commands with no priv can not be executed in PM
return;
}
;
else if (x.hasFlags(confCommand.privilege) == false)
{
- log.log(Level.INFO, "Denied access to " + confCommand.name + " to " + x + " [user has no priv]");
+ log.info("Denied access to " + confCommand.name + " to " + x + " [user has no priv]");
return;
}
}
}
catch (Exception ex)
{
- log.log(Level.WARNING, "Error running command " + confCommand.name, ex);
+ log.warn("Error running command " + confCommand.name, ex);
}
}
catch (Exception e)
{
- log.log(Level.SEVERE, "Error processing PRIVMSG: " + msg, e);
+ log.error("Error processing PRIVMSG: " + msg, e);
}
}
public static void onDie(String msg)
{
- log.log(Level.INFO, msg);
+ log.info(msg);
}
public static void onSync()
{
syncTime = (int) new Date().getTime() - (int) startTime;
- log.log(Level.INFO, "Synced in " + (double) syncTime / 1000 + " seconds.");
+ log.info("Synced in " + (double) syncTime / 1000 + " seconds.");
for (Event e : Event.getEvents())
e.onSync();
{
Blowfish bf = new Blowfish(crypto_pass);
message = bf.Encrypt(message);
- log.log(Level.FINE, "Blowfish encrypted:" + message);
+ log.debug("Blowfish encrypted:" + message);
}
Protocol.privmsg(conf.general.control, recipient.getName(), message);
{
Blowfish bf = new Blowfish(crypto_pass);
message = bf.Encrypt(message);
- log.log(Level.FINE, "Blowfish encrypted:" + message);
+ log.debug("Blowfish encrypted:" + message);
}
}
Protocol.privmsg(source, target, message);
}
catch (Exception e)
{
- log.log(Level.WARNING, "Unable to write to logfile", e);
+ log.warn("Unable to write to logfile", e);
}
f = null;
}
}
catch (Exception e)
{
- log.log(Level.WARNING, "Unable to create file", e);
+ log.warn("Unable to create file", e);
}
}
// all successful, let's create and return the BufferedWriter
}
catch (Exception e)
{
- log.log(Level.WARNING, e.getMessage(), e);
+ log.warn(null, e);
}
return null;
}
import java.util.HashMap;
import java.util.Set;
import java.util.TreeMap;
-import java.util.logging.Level;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Channel
{
- private static final Logger log = Logger.getLogger(Channel.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(Channel.class);
private int ts;
private String channel;
public void reset(int ts)
{
- log.log(Level.FINE, "Lowering TS of " + channel + " from " + this.ts + " to " + ts);
+ log.debug("Lowering TS of " + channel + " from " + this.ts + " to " + ts);
this.ts = ts;
for (Membership cm : list.values())
list.put(newnick.toLowerCase(), user);
}
else
- log.log(Level.WARNING, "Channel::onNick unknown nick change for " + oldnick + " -> " + newnick);
+ log.warn("Channel::onNick unknown nick change for " + oldnick + " -> " + newnick);
}
+++ /dev/null
-package net.rizon.acid.core;
-
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.logging.Handler;
-import java.util.logging.Level;
-import java.util.logging.LogRecord;
-
-final class loggerHandler extends Handler
-{
- private static final DateFormat format = new SimpleDateFormat("EEE MMM dd kk:mm:ss:SSSS yyyy");
-
- public loggerHandler()
- {
- this.setLevel(Level.ALL);
- }
-
- @Override
- public void close() throws SecurityException { }
-
- @Override
- public void flush() { }
-
- @Override
- public void publish(LogRecord record)
- {
- String message = record.getMessage();
- StackTraceElement[] stes = (record.getThrown() != null ? record.getThrown().getStackTrace() : null);
- boolean bad = record.getLevel() == Level.SEVERE || record.getLevel() == Level.WARNING || record.getLevel() == Level.ALL || record.getLevel() == Level.CONFIG;
-
- if (record.getLevel() == Level.INFO || bad)
- if (AcidCore.me != null && !AcidCore.me.isBursting() && User.findUser(Acidictive.conf.general.control) != null)
- {
- if (message != null)
- Acidictive.privmsg(Acidictive.conf.getChannelNamed("routing-spam"), message);
- if (stes != null)
- {
- Acidictive.privmsg(Acidictive.conf.getChannelNamed("routing-spam"), record.getThrown().toString());
- for (StackTraceElement ste : stes)
- Acidictive.privmsg(Acidictive.conf.getChannelNamed("routing-spam"), ste.toString());
- }
- }
-
- if (Acidictive.conf == null || Acidictive.conf.debug || bad)
- {
- System.out.println(format.format(new Date(record.getMillis())) + " [" + record.getLevel().getName() + "] [" + record.getLoggerName() + "] " + message);
- if (stes != null)
- {
- System.out.println(record.getThrown().toString());
- for (StackTraceElement ste : stes)
- System.out.println(ste.toString());
- }
- }
- }
-}
-
-public class Logger extends java.util.logging.Logger
-{
- private static HashMap<String, Logger> loggers = new HashMap<String, Logger>();
- private static final loggerHandler handler = new loggerHandler();
-
- protected Logger(String name, String resourceBundleName)
- {
- super(name, resourceBundleName);
- }
-
- public static Logger getLogger(final String name)
- {
- Logger l = loggers.get(name);
- if (l != null)
- return l;
-
- l = new Logger(name, null);
- loggers.put(name, l);
-
- l.setLevel(Level.ALL);
- l.addHandler(handler);
- return l;
- }
-
- public void log(Exception ex)
- {
- this.log(Level.SEVERE, null, ex);
- }
-}
\ No newline at end of file
package net.rizon.acid.core;
import java.util.HashMap;
-import java.util.logging.Level;
-
import net.rizon.acid.util.ClassLoader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public abstract class Message
{
+ private static final Logger log = LoggerFactory.getLogger(Message.class);
+
public static final char BOLD = 2;
private static final String messageBase = "net.rizon.acid.messages";
}
catch (Exception ex)
{
- AcidCore.log.log(Level.SEVERE, "Error initializing messages", ex);
+ log.error("Error initializing messages", ex);
System.exit(-1);
}
}
import java.lang.reflect.Constructor;
import java.util.LinkedList;
-
import net.rizon.acid.util.ClassLoader;
public abstract class Plugin
package net.rizon.acid.core;
-import java.util.logging.Level;
-import static net.rizon.acid.core.AcidCore.getTS;
-import static net.rizon.acid.core.AcidCore.me;
-import static net.rizon.acid.core.AcidCore.password;
import net.rizon.acid.io.IRCMessage;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Protocol
{
- private static final Logger log = Logger.getLogger(Protocol.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(Protocol.class);
private static void send(String source, String command, Object... args)
{
{
if (u.getServer() != AcidCore.me)
{
- log.log(Level.WARNING, "Fake direction for JOIN " + u.getServer().getName() + " <-> " + AcidCore.me.getName());
+ log.warn("Fake direction for JOIN " + u.getServer().getName() + " <-> " + AcidCore.me.getName());
return;
}
{
if (u.getServer() != AcidCore.me)
{
- log.log(Level.WARNING, "Fake direction for SJOIN " + u.getServer().getName() + " <-> " + AcidCore.me.getName());
+ log.warn("Fake direction for SJOIN " + u.getServer().getName() + " <-> " + AcidCore.me.getName());
return;
}
{
if (u.getServer() != AcidCore.me)
{
- log.log(Level.WARNING, "Fake direction for PART " + u.getServer().getName() + " <-> " + AcidCore.me.getName());
+ log.warn("Fake direction for PART " + u.getServer().getName() + " <-> " + AcidCore.me.getName());
return;
}
{
if (u.getServer() != AcidCore.me)
{
- log.log(Level.WARNING, "Fake direction for QUIT " + u.getServer().getName() + " <-> " + AcidCore.me.getName());
+ log.warn("Fake direction for QUIT " + u.getServer().getName() + " <-> " + AcidCore.me.getName());
return;
}
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
-import java.util.logging.Level;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Server
{
- private static final Logger log = Logger.getLogger(Server.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(Server.class);
+
private String name, description, SID;
private Server hub;
private int linkTime, syncTime, users, recordusers, hops;
sidMap.put(SID, this);
serverMap.put(name.toLowerCase(), this);
- log.log(Level.FINE, "New server: " + name + " (SID: " + SID + ") uplinked to " + (hub != null ? hub.getName() : "nothing"));
+ log.debug("New server: " + name + " (SID: " + SID + ") uplinked to " + (hub != null ? hub.getName() : "nothing"));
}
public void onQuit()
if (this.users < 0)
{
this.users = 0;
- log.log(Level.WARNING, "User count for " + this.getName() + " managed to drop below 0?");
+ log.warn("User count for " + this.getName() + " managed to drop below 0?");
}
}
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
-import java.util.logging.Level;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public abstract class Timer
{
- private static final Logger log = Logger.getLogger(Timer.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(Timer.class);
+
private static ArrayList<Timer> timers = new ArrayList<Timer>();
public Date creation;
}
catch (Exception ex)
{
- log.log(Level.SEVERE, "Error running timer", ex);
+ log.error("Error running timer", ex);
}
if (t.repeating == false)
t.stop();
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
-import java.util.logging.Level;
-
import net.rizon.acid.conf.AccessPreset;
-import net.rizon.acid.util.CloakGenerator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class User implements Comparable<User>
{
- private static final Logger log = Logger.getLogger(User.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(User.class);
+
private String nick, user, host, vhost, name, identnick, modes, UID, ip,
certfp, authflags, su;
private String cloakedIp, cloakedHost;
}
catch (SQLException ex)
{
- log.log(Level.WARNING, "Unable to load access for user", ex);
+ log.warn("Unable to load access for user", ex);
}
}
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
-import java.util.logging.Level;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Version
{
- private static final Logger log = Logger.getLogger(Version.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(Version.class);
private static HashMap<String, String> values = new HashMap<String, String>();
public static void load()
}
catch (IOException ex)
{
- log.log(Level.INFO, "Unable to load GIT version data", ex);
+ log.info("Unable to load GIT version data", ex);
}
}
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
-import java.util.logging.Level;
import net.rizon.acid.core.AcidCore;
-import net.rizon.acid.core.Logger;
+import org.slf4j.LoggerFactory;
public class AcidHandler extends SimpleChannelInboundHandler<IRCMessage>
{
- private static final Logger log = Logger.getLogger(AcidHandler.class.getName());
+ private static final org.slf4j.Logger log = LoggerFactory.getLogger(AcidHandler.class);
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception
{
AcidCore.onConnect();
-// synchronized (plexus.getIrc())
-// {
-// assert client == null;
-//
-// plexus.getStats().incrementTotalConnections();
-//
-// try
-// {
-// client = new Client(plexus, ctx.channel());
-// }
-// catch (Exception ex)
-// {
-// logger.error("Unable to accept new connections", ex);
-// return;
-// }
-//
-// plexus.getClientManager().insertClient(client);
-//
-// client.startAuth();
-// }
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception
{
AcidCore.onDisconnect();
-// synchronized (plexus.getIrc())
-// {
-// client.exit("Connection closed");
-//
-// plexus.getClientManager().removeClient(client);
-// }
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, IRCMessage message) throws Exception
{
AcidCore.processMessage(message);
-// synchronized (plexus.getIrc())
-// {
-// client.onRead(message);
-// }
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
{
- log.log(Level.SEVERE, "Uncaught exception in pipeline", cause);
- //ctx.close();
-// if (cause instanceof TooLongFrameException)
-// {
-// // thrown by LineBasedFrameDecoder
-// logger.debug("Too long of frame from " + client, cause);
-// return;
-// }
-//
-// logger.error("Exception while processing client " + client, cause);
- }
-
- @Override
- public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception
- {
-// if (!(evt instanceof ThrottleLimitExceededEvent))
-// {
-// return;
-// }
-//
-// client.exit("Excess Flood");
+ log.error("Uncaught exception in pipeline", cause);
}
}
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
-import java.util.logging.Level;
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
-import net.rizon.acid.core.Logger;
import net.rizon.acid.core.Protocol;
+import org.slf4j.LoggerFactory;
public class IdleHandler extends SimpleChannelInboundHandler
{
- private static final Logger log = Logger.getLogger(SimpleChannelInboundHandler.class.getName());
+ private static final org.slf4j.Logger log = LoggerFactory.getLogger(SimpleChannelInboundHandler.class);
private boolean idle;
}
else
{
- log.log(Level.WARNING, "No read from uplink in 120 seconds, closing connection");
+ log.warn("No read from uplink in 120 seconds, closing connection");
ctx.close();
}
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
-import java.util.logging.Level;
-import net.rizon.acid.core.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
@Sharable
public class InboundLoggingHandler extends SimpleChannelInboundHandler<IRCMessage>
{
- private static final Logger log = Logger.getLogger(InboundLoggingHandler.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(InboundLoggingHandler.class);
@Override
public void channelRead0(ChannelHandlerContext ctx, IRCMessage msg) throws Exception
{
- log.log(Level.FINE, "<- " + msg);
+ log.debug("<- {}", msg);
ctx.fireChannelRead(msg);
}
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPromise;
-import java.util.logging.Level;
-import net.rizon.acid.core.Logger;
+import org.slf4j.LoggerFactory;
@Sharable
public class OutboundLoggingHandler extends ChannelOutboundHandlerAdapter
{
- private static final Logger log = Logger.getLogger(OutboundLoggingHandler.class.getName());
+ private static final org.slf4j.Logger log = LoggerFactory.getLogger(OutboundLoggingHandler.class);
@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception
{
- log.log(Level.FINE, "-> " + msg);
+ log.debug("-> {}", msg);
ctx.write(msg, promise);
}
--- /dev/null
+package net.rizon.acid.logging;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.filter.Filter;
+import ch.qos.logback.core.spi.FilterReply;
+import net.rizon.acid.core.Acidictive;
+
+public class ConsoleFilter extends Filter<ILoggingEvent>
+{
+ @Override
+ public FilterReply decide(ILoggingEvent event)
+ {
+ boolean show = Acidictive.conf.debug || event.getLevel() != Level.DEBUG;;
+ return show ? FilterReply.ACCEPT : FilterReply.DENY;
+ }
+
+}
--- /dev/null
+package net.rizon.acid.logging;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.classic.spi.IThrowableProxy;
+import ch.qos.logback.classic.spi.StackTraceElementProxy;
+import ch.qos.logback.core.UnsynchronizedAppenderBase;
+import java.util.ArrayList;
+import java.util.List;
+import net.rizon.acid.core.AcidCore;
+import net.rizon.acid.core.Acidictive;
+import net.rizon.acid.core.User;
+
+public class Logger extends UnsynchronizedAppenderBase<ILoggingEvent>
+{
+ @Override
+ protected void append(ILoggingEvent event)
+ {
+ Level level = event.getLevel();
+ if (!level.isGreaterOrEqual(Level.INFO))
+ {
+ return;
+ }
+
+ String message = event.getMessage();
+ IThrowableProxy throwable = event.getThrowableProxy();
+ StackTraceElement[] stes = null;
+
+ if (throwable != null)
+ {
+ List<StackTraceElement> list = new ArrayList<>();
+ for (StackTraceElementProxy step : throwable.getStackTraceElementProxyArray())
+ {
+ list.add(step.getStackTraceElement());
+ }
+ stes = list.toArray(new StackTraceElement[0]);
+ }
+
+ if (AcidCore.me != null && !AcidCore.me.isBursting() && User.findUser(Acidictive.conf.general.control) != null)
+ {
+ if (message != null)
+ {
+ Acidictive.privmsg(Acidictive.conf.getChannelNamed("routing-spam"), message);
+ }
+ if (stes != null)
+ {
+ Acidictive.privmsg(Acidictive.conf.getChannelNamed("routing-spam"), throwable.getMessage());
+ for (StackTraceElement ste : stes)
+ {
+ Acidictive.privmsg(Acidictive.conf.getChannelNamed("routing-spam"), ste.toString());
+ }
+ }
+ }
+ }
+}
--- /dev/null
+package net.rizon.acid.logging;
+
+import org.slf4j.Logger;
+
+public class LoggerUtils
+{
+ public static void initThread(final Logger logger, Thread t)
+ {
+ t.setUncaughtExceptionHandler((Thread t1, Throwable e) ->
+ {
+ logger.error("uncaught exception", e);
+ });
+ }
+}
package net.rizon.acid.messages;
-import java.util.ArrayList;
-import java.util.List;
import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Message;
package net.rizon.acid.messages;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Message;
-import net.rizon.acid.core.Server;
import net.rizon.acid.core.User;
public class Invite extends Message
package net.rizon.acid.messages;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.Server;
import net.rizon.acid.core.User;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Kick extends Message
{
+ private static final Logger log = LoggerFactory.getLogger(Kick.class);
+
public Kick()
{
super("KICK");
User kickee = User.findUser(params[1]);
if (kickee == null)
{
- AcidCore.log.log(Level.WARNING, "KICK for nonexistent user " + params[1]);
+ log.warn("KICK for nonexistent user " + params[1]);
return;
}
if (kicker == source)
kicker = Server.toName(source);
if (kicker == source)
- AcidCore.log.log(Level.WARNING, "KICK from nonexitent source " + source);
+ log.warn("KICK from nonexitent source " + source);
Channel chan = Channel.findChannel(channel);
if (chan == null)
{
- AcidCore.log.log(Level.WARNING, "KICK from " + kicker + " for " + kickee.getNick() + " on nonexistent channel " + channel);
+ log.warn("KICK from " + kicker + " for " + kickee.getNick() + " on nonexistent channel " + channel);
return;
}
package net.rizon.acid.messages;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.User;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Mode extends Message
{
+ private static final Logger log = LoggerFactory.getLogger(Mode.class);
+
public Mode()
{
super("MODE");
User setter = User.findUser(source), target = User.findUser(params[0]);
if (setter == null)
{
- AcidCore.log.log(Level.WARNING, "MODE from nonexistent source " + source);
+ log.warn("MODE from nonexistent source " + source);
return;
}
else if (target == null)
{
- AcidCore.log.log(Level.WARNING, "MODE for nonexistent user " + params[0]);
+ log.warn("MODE for nonexistent user " + params[0]);
return;
}
package net.rizon.acid.messages;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.User;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Part extends Message
{
+ private static final Logger log = LoggerFactory.getLogger(Part.class);
+
public Part()
{
super("PART");
Channel chan = Channel.findChannel(params[0]);
if (chan == null)
{
- AcidCore.log.log(Level.WARNING, "PART from " + u.getNick() + " for nonexistent channel " + params[0]);
+ log.warn("PART from " + u.getNick() + " for nonexistent channel " + params[0]);
return;
}
package net.rizon.acid.messages;
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.Protocol;
package net.rizon.acid.messages;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.User;
import net.rizon.acid.util.Blowfish;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Privmsg extends Message
{
+ private static final Logger log = LoggerFactory.getLogger(Privmsg.class);
+
public Privmsg()
{
super("PRIVMSG");
return; // Don't process non-encrypted messages sent to targets expecting encrypted messages
msg = dec;
- AcidCore.log.log(Level.FINE, "Blowfish decrypted: " + msg);
+ log.debug("Blowfish decrypted: {}", msg);
}
catch (Exception e)
{
- AcidCore.log.log(Level.WARNING, "Unable to blowfish decrypt: " + msg, e);
+ log.warn("Unable to blowfish decrypt: " + msg, e);
return; // Don't process non-encrypted messages sent to targets expecting encrypted messages
}
}
package net.rizon.acid.messages;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.Server;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class SID extends Message
{
+ private static final Logger log = LoggerFactory.getLogger(SID.class);
+
public SID()
{
super("SID");
server = Server.findServer(params[2]);
if (server != null)
{
- AcidCore.log.log(Level.WARNING, "Server " + server.getName() + " (" + params[2] + "/" + server.getSID() + ") introduced from " + from.getName() + ", but already exists from " + (server.getHub() != null ? server.getHub().getName() : " no uplink"));
+ log.warn("Server " + server.getName() + " (" + params[2] + "/" + server.getSID() + ") introduced from " + from.getName() + ", but already exists from " + (server.getHub() != null ? server.getHub().getName() : " no uplink"));
return;
}
package net.rizon.acid.messages;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.Server;
import net.rizon.acid.core.User;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class SJoin extends Message
{
+ private static final Logger log = LoggerFactory.getLogger(SJoin.class);
+
public SJoin()
{
super("SJOIN");
users[i].addChan(chan);
}
else
- AcidCore.log.log(Level.WARNING, "SJOIN for nonexistant user " + stripped_user + " from " + source.getName());
+ log.warn("SJOIN for nonexistant user " + stripped_user + " from " + source.getName());
}
if (source.isBursting() == false)
package net.rizon.acid.messages;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.Server;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class SQuit extends Message
{
+ private static final Logger log = LoggerFactory.getLogger(SQuit.class);
+
public SQuit()
{
super("SQUIT");
Server x = Server.findServer(params[0]);
if (x == null)
{
- AcidCore.log.log(Level.WARNING, "SQUIT for nonexistent server " + params[0]);
+ log.warn("SQUIT for nonexistent server " + params[0]);
return;
}
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
-
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.Protocol;
package net.rizon.acid.messages;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.Server;
import net.rizon.acid.core.User;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class TMode extends Message
{
+ private static final Logger log = LoggerFactory.getLogger(TMode.class);
+
public TMode()
{
super("TMODE");
setter = User.toName(source);
if (setter == source)
{
- AcidCore.log.log(Level.WARNING, "TMODE from nonexistent source " + source);
+ log.warn("TMODE from nonexistent source " + source);
return;
}
package net.rizon.acid.messages;
-import java.util.logging.Level;
-
import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Message;
import net.rizon.acid.core.Protocol;
import net.rizon.acid.core.User;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Whois extends Message
{
+ private static final Logger log = LoggerFactory.getLogger(Whois.class);
+
public Whois()
{
super("WHOIS");
if (u == null)
{
- AcidCore.log.log(Level.WARNING, "Whois for nonexistent nick " + params[0]);
+ log.warn("Whois for nonexistent nick " + params[0]);
return;
}
else if (u.getServer() != AcidCore.me)
{
- AcidCore.log.log(Level.WARNING, "Fake direction for whois (" + u.getServer().getName() + ")");
+ log.warn("Fake direction for whois (" + u.getServer().getName() + ")");
return;
}
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.LinkedList;
-import java.util.logging.Level;
-
import net.rizon.acid.conf.Database;
import net.rizon.acid.core.Acidictive;
-import net.rizon.acid.core.Logger;
+import org.slf4j.LoggerFactory;
public class SQL extends Thread
{
- private static final Logger log = Logger.getLogger(SQL.class.getName());
+ private static final org.slf4j.Logger log = LoggerFactory.getLogger(SQL.class);
+
private PreparedStatement statement;
private ResultSet result;
private String url, username, password;
{
this.shuttingDown = true;
- log.log(Level.INFO, "Flushing pending SQL queries...");
+ log.info("Flushing pending SQL queries...");
synchronized (this.queryLock)
{
catch (InterruptedException ex) { }
}
- log.log(Level.INFO, "All SQL queries successfully flushed");
+ log.info("All SQL queries successfully flushed");
try { this.con.close(); }
catch (Exception ex) { }
this.last_connect = System.currentTimeMillis();
this.con = DriverManager.getConnection(this.url, this.username, this.password);
- log.log(Level.INFO, "Successfully connected to " + this.version() + " using " + this.con.getMetaData().getDriverName() + " (" + this.con.getMetaData().getDriverVersion() + ")");
+ log.info("Successfully connected to " + this.version() + " using " + this.con.getMetaData().getDriverName() + " (" + this.con.getMetaData().getDriverVersion() + ")");
}
public PreparedStatement prepare(final String statement) throws SQLException
public int executeUpdateBlocking(PreparedStatement statement) throws SQLException
{
int i = statement.executeUpdate();
- log.log(Level.FINE, "Successfully executed " + statement);
+ log.debug("Successfully executed " + statement);
return i;
}
{
this.result = statement.executeQuery();
- log.log(Level.FINE, "Successfully executed " + statement);
+ log.debug("Successfully executed " + statement);
return this.result;
}
q.executeUpdate();
lastQuery = System.currentTimeMillis();
- log.log(Level.FINE, "Successfully executed " + q + " in worker thread");
+ log.debug("Successfully executed " + q + " in worker thread");
}
catch (SQLException ex)
{
long now = System.currentTimeMillis() / 1000L;
if (lastWarn + 60 < now)
{
- log.log(Level.SEVERE, reason, ex);
+ log.error(reason, ex);
lastWarn = now;
}
}
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
-
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
-
-import net.rizon.acid.core.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Blowfish
{
- private static final Logger log = Logger.getLogger(Blowfish.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(Blowfish.class);
/*
* Constructor of Blowfish class Key param
}
catch (Exception e)
{
- log.log(e);
+ log.error(null, e);
}
}
}
catch (InvalidKeyException e)
{
- log.log(e);
+ log.error(null, e);
}
String REncrypt = "";
}
catch (Exception e)
{
- log.log(e);
+ log.error(null, e);
}
REncrypt = Begin.concat(REncrypt);
}
catch (UnsupportedEncodingException e)
{
- log.log(e);
+ log.error(null, e);
}
return Result;
}
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
-import java.util.logging.Level;
-
-import net.rizon.acid.core.Logger;
import net.rizon.acid.core.Plugin;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public final class ClassLoader extends URLClassLoader
{
- private static final Logger log = Logger.getLogger(ClassLoader.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(ClassLoader.class);
public ClassLoader(String plugin, String classname)
{
/* can't find the directory where we expect it */
if (!targetFolder.exists())
{
- log.log(Level.WARNING, "Unable to find " + pluginPath + "/target/ directory to source the JAR from.");
+ log.warn("Unable to find " + pluginPath + "/target/ directory to source the JAR from.");
return;
}
File f = new File(targetFolder, "classes/");
if (!f.isDirectory())
{
- log.log(Level.WARNING, "Unable to locate plugin JAR/class files for " + plugin);
+ log.warn("Unable to locate plugin JAR/class files for " + plugin);
return;
}
- log.log(Level.FINE, "Using classes/ for plugin " + plugin);
+ log.warn("Using classes/ for plugin " + plugin);
try
{
this.addURL(f.toURI().toURL());
}
catch (MalformedURLException ex)
{
- log.log(Level.WARNING, "Unable to add class URL for " + plugin + " [" + f.toURI() + "]", ex);
+ log.warn("Unable to add class URL for " + plugin + " [" + f.toURI() + "]", ex);
}
return;
}
else
{
- log.log(Level.FINE, "Found load candidate " + jar.getName() + " for plugin `" + plugin + "`");
+ log.debug("Found load candidate " + jar.getName() + " for plugin `" + plugin + "`");
}
}
else
}
catch (MalformedURLException ex)
{
- log.log(Level.WARNING, "Unable to add plugin JAR URL for " + plugin + " [" + jar.toURI() + "]", ex);
+ log.warn("Unable to add plugin JAR URL for " + plugin + " [" + jar.toURI() + "]", ex);
}
}
else
{
- log.log(Level.WARNING, "Unable to locate JAR for plugin " + plugin);
+ log.warn("Unable to locate JAR for plugin " + plugin);
}
}
package net.rizon.acid.util;
-import java.net.InetAddress;
import java.net.Inet4Address;
import java.net.Inet6Address;
+import java.net.InetAddress;
import java.net.UnknownHostException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Date;
import java.util.Properties;
-
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
-
import net.rizon.acid.core.Acidictive;
-import net.rizon.acid.core.Logger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Handles sending e-mails.
*/
public class EMail
{
- private static final Logger log = Logger.getLogger(EMail.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(EMail.class);
public EMail(String to, String subject, String msg)
{
}
catch(MessagingException e)
{
- log.log(e);
+ log.error(null, e);
}
}
}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>\r
+\r
+<configuration>\r
+ <timestamp key="byDay" datePattern="yyyyMMdd"/>\r
+\r
+ <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">\r
+ <filter class="net.rizon.moo.logging.ConsoleFilter" />\r
+\r
+ <encoder>\r
+ <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{5} - %msg%n</pattern>\r
+ </encoder>\r
+ </appender>\r
+ \r
+ <appender name="FILE" class="ch.qos.logback.core.FileAppender">\r
+ <filter class="net.rizon.acid.logging.ConsoleFilter" />\r
+ <file>moo-${byDay}.log</file>\r
+ <append>true</append>\r
+ \r
+ <encoder>\r
+ <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{35} - %msg%n</pattern>\r
+ </encoder>\r
+ </appender>\r
+ \r
+ <appender name="IRC" class="net.rizon.acid.logging.Logger" />\r
+\r
+ <root level="DEBUG"> \r
+ <appender-ref ref="STDOUT" />\r
+ <appender-ref ref="FILE" />\r
+ <appender-ref ref="IRC" />\r
+ </root>\r
+ \r
+</configuration>\r
package net.rizon.acid.plugins.pyva.pyva.commands;
-import static net.rizon.acid.core.Acidictive.reply;
import net.rizon.acid.core.AcidUser;
+import static net.rizon.acid.core.Acidictive.reply;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Command;
import net.rizon.acid.core.User;
package net.rizon.acid.plugins.pyva.pyva.commands;
-import java.util.logging.Level;
-
import net.rizon.acid.core.AcidUser;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Command;
-import net.rizon.acid.core.Logger;
import net.rizon.acid.core.User;
import net.rizon.acid.plugins.pyva.pyva.pyva;
import net.rizon.pyva.PyvaException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class Plugins extends Command
{
- private static final Logger log = Logger.getLogger(Plugins.class.getName());
+ private static final Logger log = LoggerFactory.getLogger(Plugins.class);
public Plugins()
{
}
catch (PyvaException e)
{
- log.log(Level.WARNING, "Unable to get current plugins", e);
+ log.warn("Unable to get current plugins", e);
return;
}
}
catch (PyvaException e)
{
- log.log(Level.WARNING, "Unable to load pyva script", e);
+ log.warn("Unable to load pyva script", e);
}
}
else if (args[0].equalsIgnoreCase("UNLOAD") && args.length == 2)
}
catch (PyvaException e)
{
- log.log(Level.WARNING, "Unable to unload pyva script", e);
+ log.warn("Unable to unload pyva script", e);
}
}
else if (args[0].equalsIgnoreCase("RELOAD") && args.length == 2)
}
catch (PyvaException e)
{
- log.log(Level.WARNING, "Unable to reload pyva script", e);
+ log.warn("Unable to reload pyva script", e);
}
}
else
package net.rizon.acid.plugins.pyva.pyva.conf;
import java.util.List;
-
import net.rizon.acid.conf.Client;
import net.rizon.acid.conf.ConfigException;
import net.rizon.acid.conf.Configuration;
import java.util.Arrays;
import java.util.Date;
-import java.util.logging.Level;
-
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Event;
-import net.rizon.acid.core.Logger;
import net.rizon.acid.core.Plugin;
-import net.rizon.acid.core.Server;
import net.rizon.acid.core.Timer;
import net.rizon.acid.core.User;
import net.rizon.acid.plugins.pyva.pyva.conf.Config;
import net.rizon.pyva.Pyva;
import net.rizon.pyva.PyvaException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
class PyvaEvent extends Event
{
}
catch (Exception e)
{
- pyva.log.log(Level.WARNING, "Error executing pyva call", e);
+ pyva.log.warn("Error executing pyva call", e);
}
}
}
public class pyva extends Plugin
{
- protected static final Logger log = Logger.getLogger(pyva.class.getName());
+ protected static final Logger log = LoggerFactory.getLogger(pyva.class);
private Config conf;
private Timer t;
}
catch (PyvaException e)
{
- log.log(Level.SEVERE, "Unable to unload pyva plugins", e);
+ log.error("Unable to unload pyva plugins", e);
}
pyva.stop();
import java.util.Date;
import java.util.Iterator;
import java.util.Map;
-
import net.rizon.acid.core.Timer;
class ExpireTimer extends Timer
import java.util.Date;
import java.util.Random;
-
import net.rizon.acid.core.Message;
import net.rizon.acid.core.Protocol;
import net.rizon.acid.core.Timer;
package net.rizon.acid.plugins.trapbot;
import java.util.Date;
-
import net.rizon.acid.core.Message;
import net.rizon.acid.core.Protocol;
import net.rizon.acid.core.Timer;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Channel;
import net.rizon.acid.core.Command;
-import net.rizon.acid.core.Protocol;
import net.rizon.acid.core.User;
import net.rizon.acid.plugins.trapbot.trapbot;
package net.rizon.acid.plugins.trapbot.conf;
import java.util.List;
-
import net.rizon.acid.conf.Client;
import net.rizon.acid.conf.ConfigException;
import net.rizon.acid.conf.Configuration;
package net.rizon.acid.plugins.trapbot;
import java.util.HashMap;
-
import net.rizon.acid.core.AcidCore;
import net.rizon.acid.core.AcidUser;
import net.rizon.acid.core.Acidictive;
import net.rizon.acid.core.Event;
-import net.rizon.acid.core.Logger;
import net.rizon.acid.core.Plugin;
import net.rizon.acid.core.Timer;
import net.rizon.acid.core.User;
import net.rizon.acid.plugins.trapbot.conf.Config;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class trapbot extends Plugin
{
- protected static final Logger log = Logger.getLogger(trapbot.class.getName());
+ protected static final Logger log = LoggerFactory.getLogger(trapbot.class);
private Event ev;
public static AcidUser trapbot;
projects / irc / rizon / acid.git / commitdiff
