package net.rizon.moo.plugin.core;
+import com.google.inject.Inject;
import net.rizon.moo.Command;
import net.rizon.moo.CommandSource;
import net.rizon.moo.Plugin;
+import net.rizon.moo.conf.Config;
-public class CommandHelp extends Command
+class CommandHelp extends Command
{
- public CommandHelp(Plugin pkg)
+ CommandHelp()
{
- super(pkg, "!HELP", "Shows this list");
+ super("!HELP", "Shows this list");
}
@Override
{
boolean show_header = false;
- for (Command c : pkg.commands)
+ for (Command c : pkg.getCommands())
{
if (!c.isRequiredChannel(source.getTargetName()))
continue;
package net.rizon.moo.plugin.core;
+import com.google.inject.Inject;
import java.net.InetAddress;
import java.net.UnknownHostException;
import net.rizon.moo.Command;
import net.rizon.moo.CommandSource;
-import net.rizon.moo.Moo;
-import net.rizon.moo.Plugin;
+import net.rizon.moo.conf.Config;
class CommandHost extends Command
{
- public CommandHost(Plugin pkg)
+ @Inject
+ CommandHost(Config conf)
{
- super(pkg, "!HOST", "Resolve a hostname");
+ super("!HOST", "Resolve a hostname");
- this.requiresChannel(Moo.conf.staff_channels);
- this.requiresChannel(Moo.conf.oper_channels);
- this.requiresChannel(Moo.conf.admin_channels);
+ this.requiresChannel(conf.staff_channels);
+ this.requiresChannel(conf.oper_channels);
+ this.requiresChannel(conf.admin_channels);
}
@Override
import net.rizon.moo.CommandSource;
import net.rizon.moo.Moo;
import net.rizon.moo.Plugin;
+import net.rizon.moo.conf.Config;
import org.slf4j.Logger;
class CommandPlugins extends Command
{
@Inject
private static Logger logger;
+
+ @Inject
+ private Moo moo;
- public CommandPlugins(Plugin pkg)
+ @Inject
+ CommandPlugins(Config conf)
{
- super(pkg, "!PLUGINS", "Manage plugins");
- this.requiresChannel(Moo.conf.admin_channels);
+ super("!PLUGINS", "Manage plugins");
+ this.requiresChannel(conf.admin_channels);
}
@Override
try
{
Plugin p = Plugin.loadPlugin(params[2]);
+ moo.rebuildInjector();
source.reply("Plugin " + p.getName() + " loaded");
}
catch (Throwable ex)
else
{
p.remove();
+ moo.rebuildInjector();
source.reply("Plugin " + p.getName() + " removed");
}
}
else
{
p.remove();
+ moo.rebuildInjector();
try
{
p = Plugin.loadPlugin(params[2]);
+ moo.rebuildInjector();
source.reply("Plugin " + p.getName() + " reloaded");
}
catch (Throwable ex)
package net.rizon.moo.plugin.core;
+import com.google.inject.Inject;
import java.util.Random;
import net.rizon.moo.Command;
class CommandRand extends Command
{
- public CommandRand(Plugin pkg)
+ @Inject
+ CommandRand()
{
- super(pkg, ".RAND", "Generate a random string");
+ super(".RAND", "Generate a random string");
}
private static String randChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@_#^&%$";
@Inject
private static Logger logger;
+ @Inject
+ private Moo moo;
+
@Inject
private EventBus eventBus;
- public CommandReload(Plugin pkg)
+ @Inject
+ CommandReload(Config conf)
{
- super(pkg, "!RELOAD", "Reloads the configuration file");
- this.requiresChannel(Moo.conf.admin_channels);
+ super("!RELOAD", "Reloads the configuration file");
+ this.requiresChannel(conf.admin_channels);
}
@Override
eventBus.post(new OnReload(source));
- Moo.conf = c;
+ moo.setConf(c);
+ moo.rebuildInjector();
+
source.reply("Successfully reloaded configuration");
}
catch (Exception ex)
import net.rizon.moo.CommandSource;
import net.rizon.moo.Moo;
import net.rizon.moo.Plugin;
+import net.rizon.moo.conf.Config;
import net.rizon.moo.irc.Protocol;
+import net.rizon.moo.plugin.core.conf.CoreConfiguration;
class shellExec extends Thread
{
+ private CoreConfiguration conf;
private Protocol protocol;
private CommandSource source;
private String command;
- public shellExec(Protocol protocol, CommandSource source, String command)
+ public shellExec(CoreConfiguration conf, Protocol protocol, CommandSource source, String command)
{
+ this.conf = conf;
this.protocol = protocol;
this.source = source;
this.command = command;
}
-
@Override
public void run()
{
try
{
- Process proc = Runtime.getRuntime().exec(this.command, null, new File(core.conf.shell.base));
+ Process proc = Runtime.getRuntime().exec(this.command, null, new File(conf.shell.base));
BufferedReader in = new BufferedReader(new InputStreamReader(proc.getInputStream()));
for (String line; (line = in.readLine()) != null;)
{
@Inject
private Protocol protocol;
- public CommandShell(Plugin pkg)
+ @Inject
+ private CoreConfiguration conf;
+
+ @Inject
+ CommandShell(Config conf)
{
- super(pkg, "!SHELL", "Execute a shell command");
- this.requiresChannel(Moo.conf.admin_channels);
+ super("!SHELL", "Execute a shell command");
+ this.requiresChannel(conf.admin_channels);
}
@Override
{
source.notice("!SHELL <command>");
source.notice("!SHELL executes a single shell command from the configured shell base directory.");
- source.notice("This command is currently " + (core.conf.shell.enabled ? "enabled" : "disabled") + ".");
+ source.notice("This command is currently " + (conf.shell.enabled ? "enabled" : "disabled") + ".");
}
@Override
public void execute(CommandSource source, String[] params)
{
- if (!core.conf.shell.enabled || params.length == 1)
+ if (!conf.shell.enabled || params.length == 1)
return;
- File base = new File(core.conf.shell.base);
+ File base = new File(conf.shell.base);
if (base.exists() == false || base.isDirectory() == false)
{
source.reply("Shell base dir is set to an invalid path");
if (param.indexOf("..") != -1)
return;
- shellExec e = new shellExec(protocol, source, param);
+ shellExec e = new shellExec(conf, protocol, source, param);
e.start();
}
}
import net.rizon.moo.CommandSource;
import net.rizon.moo.Moo;
import net.rizon.moo.Plugin;
+import net.rizon.moo.conf.Config;
import net.rizon.moo.irc.Protocol;
@Inject
private Protocol protocol;
- public CommandShutdown(Plugin pkg)
+ @Inject
+ private Config conf;
+
+ @Inject
+ CommandShutdown(Config conf)
{
- super(pkg, "!SHUTDOWN", "Shutdown " + Moo.conf.general.nick);
- this.requiresChannel(Moo.conf.admin_channels);
+ super("!SHUTDOWN", "Shutdown " + conf.general.nick);
+ this.requiresChannel(conf.admin_channels);
}
@Override
public void onHelp(CommandSource source)
{
source.notice("Syntax: !SHUTDOWN");
- source.notice("!SHUTDOWN shuts " + Moo.conf.general.nick + " down.");
+ source.notice("!SHUTDOWN shuts " + conf.general.nick + " down.");
source.notice("Please note that this will show the nick!user@host of the user");
source.notice("issuing this command in the quit message.");
}
package net.rizon.moo.plugin.core;
+import com.google.inject.Inject;
import net.rizon.moo.Command;
import net.rizon.moo.CommandSource;
import net.rizon.moo.Moo;
import net.rizon.moo.Plugin;
import net.rizon.moo.Version;
+import net.rizon.moo.conf.Config;
class CommandStatus extends Command
{
- public CommandStatus(Plugin pkg)
+ @Inject
+ private Config conf;
+
+ @Inject
+ CommandStatus(Config conf)
{
- super(pkg, "!STATUS", "View " + Moo.conf.general.nick + "'s status");
+ super("!STATUS", "View " + conf.general.nick + "'s status");
}
private String convertBytes(long bb)
public void onHelp(CommandSource source)
{
source.notice("Syntax: !STATUS");
- source.notice("!STATUS prints misc info on " + Moo.conf.general.nick + ".");
- source.notice("This includes the version, the date when " + Moo.conf.general.nick + " was started,");
+ source.notice("!STATUS prints misc info on " + conf.general.nick + ".");
+ source.notice("This includes the version, the date when " + conf.general.nick + " was started,");
source.notice("the amount of currently running threads and memory usage.");
}
@Override
public void execute(CommandSource source, String[] params)
{
- source.reply("[STATUS] " + Moo.conf.general.nick + " version " + Moo.conf.version + ", created on " + Moo.getCreated() + ". Revision " + Version.getFullVersion() + ". Using " + Thread.activeCount() + " threads and " + this.getMemory() + " of memory");
+ source.reply("[STATUS] " + conf.general.nick + " version " + conf.version + ", created on " + Moo.getCreated() + ". Revision " + Version.getFullVersion() + ". Using " + Thread.activeCount() + " threads and " + this.getMemory() + " of memory");
}
}
\ No newline at end of file
import com.google.common.eventbus.Subscribe;
import com.google.inject.Inject;
import com.google.inject.multibindings.Multibinder;
+import java.util.Arrays;
+import java.util.List;
import net.rizon.moo.Command;
-import net.rizon.moo.Moo;
import net.rizon.moo.Plugin;
import net.rizon.moo.events.EventListener;
import net.rizon.moo.events.OnReload;
import net.rizon.moo.plugin.core.conf.CoreConfiguration;
import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
public class core extends Plugin implements EventListener
{
@Inject
private static Logger logger;
-
- public static CoreConfiguration conf;
+ private CoreConfiguration conf;
+
+ @Inject
private CommandHelp help;
- private Command host, plugins, rand, reload, shell, shutdown, status;
+
+ @Inject
+ private CommandHost host;
+
+ @Inject
+ private CommandPlugins plugins;
+
+ @Inject
+ private CommandRand rand;
+
+ @Inject
+ private CommandReload reload;
+
+ @Inject
+ private CommandShell shell;
+
+ @Inject
+ private CommandShutdown shutdown;
+
+ @Inject
+ private CommandStatus status;
public core() throws Exception
{
conf = CoreConfiguration.load();
}
-
@Override
protected void configure()
{
- help = new CommandHelp(this);
- host = new CommandHost(this);
- plugins = new CommandPlugins(this);
- rand = new CommandRand(this);
- reload = new CommandReload(this);
- shell = new CommandShell(this);
- shutdown = new CommandShutdown(this);
- status = new CommandStatus(this);
+ bind(core.class).toInstance(this);
+
+ bind(CoreConfiguration.class).toInstance(conf);
Multibinder<Command> commandBinder = Multibinder.newSetBinder(binder(), Command.class);
- commandBinder.addBinding().toInstance(help);
- commandBinder.addBinding().toInstance(host);
- commandBinder.addBinding().toInstance(plugins);
- commandBinder.addBinding().toInstance(rand);
- commandBinder.addBinding().toInstance(reload);
- commandBinder.addBinding().toInstance(shell);
- commandBinder.addBinding().toInstance(shutdown);
- commandBinder.addBinding().toInstance(status);
+ commandBinder.addBinding().to(CommandHelp.class);
+ commandBinder.addBinding().to(CommandHost.class);
+ commandBinder.addBinding().to(CommandPlugins.class);
+ commandBinder.addBinding().to(CommandRand.class);
+ commandBinder.addBinding().to(CommandReload.class);
+ commandBinder.addBinding().to(CommandShell.class);
+ commandBinder.addBinding().to(CommandShutdown.class);
+ commandBinder.addBinding().to(CommandStatus.class);
Multibinder<EventListener> eventListenerBinder = Multibinder.newSetBinder(binder(), EventListener.class);
eventListenerBinder.addBinding().toInstance(this);
@Override
public void stop()
{
- help.remove();
- host.remove();
- plugins.remove();
- rand.remove();
- reload.remove();
- shell.remove();
- shutdown.remove();
- status.remove();
}
@Subscribe
{
try
{
- core.conf = CoreConfiguration.load();
+ conf = CoreConfiguration.load();
}
catch (Exception ex)
{
logger.warn("Unable to reload core configuration", ex);
}
}
+
+ @Override
+ public List<Command> getCommands()
+ {
+ return Arrays.asList(help, host, plugins, rand, reload, shell, shutdown, status);
+ }
}
package net.rizon.moo.plugin.dnsbl;
+import com.google.inject.Inject;
import java.util.Collection;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
-import java.util.logging.Level;
import net.rizon.moo.plugin.dnsbl.actions.Action;
+import net.rizon.moo.plugin.dnsbl.conf.DnsblConfiguration;
import net.rizon.moo.plugin.dnsbl.conf.DnsblServerConfiguration;
import net.rizon.moo.plugin.dnsbl.conf.RuleConfiguration;
import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
class BlacklistManager
{
- private static final Logger logger = LoggerFactory.getLogger(BlacklistManager.class);
+ @Inject
+ private static Logger logger;
+
+ @Inject
+ private dnsbl dnsbl;
+
+ @Inject
+ private DnsblConfiguration conf;
- private Map<String, Blacklist> blacklists = new HashMap<String, Blacklist>();
+ private Map<String, Blacklist> blacklists = new HashMap<>();
- /**
- * Loads the list of DNSBL server configuration.
- * @param configuration List of server configurations.
- */
- public void load(List<DnsblServerConfiguration> configuration)
+ public void load()
{
blacklists.clear();
- for (DnsblServerConfiguration c : configuration)
+ for (DnsblServerConfiguration c : conf.servers)
{
Blacklist b = new Blacklist(c.address);
blacklists.put(c.address, b);
if (response.equals(Rule.RESPONSE_ANY))
response = null;
- Action action = Action.getByName(rule.action);
+ Action action = dnsbl.getByName(rule.action);
if (action == null)
{
// Invalid config item, ignore it.
package net.rizon.moo.plugin.dnsbl;
+import com.google.inject.Inject;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import net.rizon.moo.Command;
import net.rizon.moo.CommandSource;
-import net.rizon.moo.Moo;
-import net.rizon.moo.Plugin;
+import net.rizon.moo.conf.Config;
import net.rizon.moo.plugin.dnsbl.actions.Action;
import org.xbill.DNS.Record;
class CommandDnsbl extends Command
{
+ @Inject
private BlacklistManager blacklists;
+
+ @Inject
private ResultCache cache;
- public CommandDnsbl(Plugin pkg, BlacklistManager blacklistManager, ResultCache cache)
+ @Inject
+ private dnsbl dnsbl;
+
+ @Inject
+ CommandDnsbl(Config conf)
{
- super(pkg, "!DNSBL", "Manage DNSBL servers");
- this.requiresChannel(Moo.conf.admin_channels);
- this.blacklists = blacklistManager;
- this.cache = cache;
+ super("!DNSBL", "Manage DNSBL servers");
+ this.requiresChannel(conf.admin_channels);
}
@Override
source.notice(" Check IP against DNSBLs and return what actions would have been taken.");
source.notice(" If server is given, only check against server. ");
source.notice("Possible actions:");
- for (Action a : Action.getAllActions())
+ for (Action a : dnsbl.getAllActions())
source.notice(" " + a.getName() + ": " + a.getDescription());
}
String host = params[0];
String response = params[1], actualResponse;
- Action action = Action.getByName(params[2].toUpperCase());
+ Action action = dnsbl.getByName(params[2].toUpperCase());
if (response.equals(Rule.RESPONSE_ANY))
actualResponse = null;
String host = params[0];
String response = params[1], actualResponse;
- Action action = Action.getByName(params[2].toUpperCase());
+ Action action = dnsbl.getByName(params[2].toUpperCase());
if (response.equals(Rule.RESPONSE_ANY))
actualResponse = null;
package net.rizon.moo.plugin.dnsbl;
+import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.logging.Level;
-
-import net.rizon.moo.CommandSource;
-import net.rizon.moo.Event;
+import javax.inject.Inject;
import net.rizon.moo.Moo;
import net.rizon.moo.events.EventClientConnect;
import net.rizon.moo.events.EventDNSBLHit;
+import net.rizon.moo.events.EventListener;
import net.rizon.moo.events.OnReload;
import net.rizon.moo.plugin.dnsbl.actions.Action;
import net.rizon.moo.plugin.dnsbl.conf.DnsblConfiguration;
import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-class EventDnsblCheck
+class EventDnsblCheck implements EventListener
{
- private static final Logger logger = LoggerFactory.getLogger(EventDnsblCheck.class);
-
+ @Inject
+ private static Logger logger;
+
+ @Inject
private BlacklistManager rules;
+ @Inject
private ResultCache cache;
- public EventDnsblCheck(BlacklistManager rules, ResultCache cache)
- {
- this.rules = rules;
- this.cache = cache;
- }
+ @Inject
+ private EventBus eventBus;
private void takeAction(String nick, String ip, List<DnsblCheckResult> results)
{
for (Map.Entry<String, List<Action>> dnsblResult : result.getActions().entrySet())
{
// XXX this is calling event from a thread
- Moo.getEventBus().post(new EventDNSBLHit(nick, ip, result.getBlacklist().getName(), dnsblResult.getKey()));
+ eventBus.post(new EventDNSBLHit(nick, ip, result.getBlacklist().getName(), dnsblResult.getKey()));
// And those responses each have a set of actions.
for (Action a : dnsblResult.getValue())
try
{
DnsblConfiguration c = DnsblConfiguration.load();
- rules.load(c.servers);
- cache.load(c.cache);
- cache.clear();
- DnsblChecker.load(c);
- dnsbl.conf = c;
+// rules.load(c.servers);
+// cache.load(c.cache);
+// cache.clear();
+// DnsblChecker.load(c);
+// dnsbl.conf = c;
}
catch (Exception ex)
{
package net.rizon.moo.plugin.dnsbl;
+import com.google.inject.Inject;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import net.rizon.moo.plugin.dnsbl.conf.CacheConfiguration;
+import net.rizon.moo.plugin.dnsbl.conf.DnsblConfiguration;
class ResultCache
{
private static final long EXPIRE_TICK = 60 * 1000L;
private long lastExpired;
- private int entryLifetime = 60;
+
+ @Inject
+ private DnsblConfiguration conf;
protected class Entry
{
private Map<String, Entry> entries = new HashMap<String, Entry>();
- /**
- * Loads the configuration for the ResultCache.
- * @param c Configuration settings to load.
- */
- public void load(CacheConfiguration c)
- {
- if (c.lifetime > 0)
- this.entryLifetime = c.lifetime;
- }
-
public synchronized void addEntry(String ip, List<DnsblCheckResult> results)
{
if (System.currentTimeMillis() > lastExpired + EXPIRE_TICK)
// Calculate expiration date.
Calendar c = Calendar.getInstance();
c.setTime(now);
- c.add(Calendar.SECOND, this.entryLifetime);
+ c.add(Calendar.SECOND, conf.cache.lifetime > 0 ? conf.cache.lifetime : 60);
Date expiration = c.getTime();
this.entries.put(ip, new Entry(results, expiration));
public abstract class Action
{
- private static Action[] allActions = { new ActionAkill(), new ActionLog() };
-
private String name;
private String description;
{
return this.description;
}
-
- public static Action[] getAllActions()
- {
- return allActions;
- }
-
- public static Action getByName(String name)
- {
- for (Action a : getAllActions())
- if (a.name.equals(name))
- return a;
-
- return null;
- }
}
package net.rizon.moo.plugin.dnsbl.actions;
-import net.rizon.moo.Moo;
+import com.google.inject.Inject;
+import static net.rizon.moo.Moo.moo;
+import net.rizon.moo.irc.Protocol;
import net.rizon.moo.plugin.dnsbl.Blacklist;
-import net.rizon.moo.plugin.dnsbl.dnsbl;
+import net.rizon.moo.plugin.dnsbl.conf.DnsblConfiguration;
public class ActionAkill extends Action
{
+ @Inject
+ private DnsblConfiguration conf;
+
+ @Inject
+ private Protocol protocol;
+
public ActionAkill()
{
super("AKILL", "Ban IP and terminate connection");
@Override
public void onHit(Blacklist blacklist, String dnsblResponse, String nick, String ip)
{
- String message = dnsbl.conf.akill.message
+ String message = conf.akill.message
.replace("%h", ip)
.replace("%d", blacklist.getName())
.replace("%r", dnsblResponse);
- Moo.akill(ip, dnsbl.conf.akill.duration, message);
+ protocol.akill(ip, conf.akill.duration, message);
}
@Override
package net.rizon.moo.plugin.dnsbl.actions;
+import com.google.inject.Inject;
import net.rizon.moo.Moo;
+import net.rizon.moo.conf.Config;
+import net.rizon.moo.irc.Protocol;
import net.rizon.moo.plugin.dnsbl.Blacklist;
public class ActionLog extends Action
{
+ @Inject
+ private Config conf;
+
+ @Inject
+ private Protocol protocol;
+
public ActionLog()
{
super("LOG", "Log connection for inspection by ircops");
@Override
public void onHit(Blacklist blacklist, String response, String nick, String ip)
{
- Moo.privmsgAll(Moo.conf.spam_channels, "DNSBL " + blacklist.getName() + " gave hit on " + nick + " (" + ip + "): " + response);
+ protocol.privmsgAll(conf.spam_channels, "DNSBL " + blacklist.getName() + " gave hit on " + nick + " (" + ip + "): " + response);
}
}
package net.rizon.moo.plugin.dnsbl;
-import net.rizon.moo.Moo;
+import com.google.inject.Inject;
+import com.google.inject.multibindings.Multibinder;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import net.rizon.moo.Command;
import net.rizon.moo.Plugin;
+import net.rizon.moo.events.EventListener;
+import net.rizon.moo.plugin.dnsbl.actions.Action;
+import net.rizon.moo.plugin.dnsbl.actions.ActionAkill;
+import net.rizon.moo.plugin.dnsbl.actions.ActionLog;
import net.rizon.moo.plugin.dnsbl.conf.DnsblConfiguration;
public class dnsbl extends Plugin
{
+ @Inject
private CommandDnsbl command;
+
+ @Inject
private BlacklistManager blacklistManager;
- private ResultCache cache;
- private EventDnsblCheck event;
- public static DnsblConfiguration conf;
+
+ @Inject
+ private Set<Action> actions;
+
+ private DnsblConfiguration conf;
public dnsbl() throws Exception
{
@Override
public void start()
{
- this.blacklistManager = new BlacklistManager();
- this.cache = new ResultCache();
- this.command = new CommandDnsbl(this, this.blacklistManager, this.cache);
- this.event = new EventDnsblCheck(this.blacklistManager, this.cache);
-
- Moo.getEventBus().register(event);
-
DnsblChecker.load(conf);
- this.cache.load(conf.cache);
- this.blacklistManager.load(conf.servers);
+ blacklistManager.load();
}
@Override
public void stop()
{
- this.command.remove();
- Moo.getEventBus().unregister(event);
+ }
+
+ @Override
+ public List<Command> getCommands()
+ {
+ return Arrays.<Command>asList(command);
+ }
+
+ @Override
+ protected void configure()
+ {
+ bind(dnsbl.class).toInstance(this);
+
+ bind(DnsblConfiguration.class).toInstance(conf);
+
+ bind(BlacklistManager.class).toInstance(new BlacklistManager());
+ bind(ResultCache.class).toInstance(new ResultCache());
+
+ Multibinder<Command> commandBinder = Multibinder.newSetBinder(binder(), Command.class);
+ commandBinder.addBinding().to(CommandDnsbl.class);
+
+ Multibinder<EventListener> eventListenerBinder = Multibinder.newSetBinder(binder(), EventListener.class);
+ eventListenerBinder.addBinding().to(EventDnsblCheck.class);
+
+ Multibinder<Action> actionBinder = Multibinder.newSetBinder(binder(), Action.class);
+ actionBinder.addBinding().to(ActionAkill.class);
+ actionBinder.addBinding().to(ActionLog.class);
+ }
+
+ public Collection<Action> getAllActions()
+ {
+ return actions;
+ }
+
+ public Action getByName(String name)
+ {
+ for (Action a : getAllActions())
+ {
+ if (a.getName().equals(name))
+ {
+ return a;
+ }
+ }
+
+ return null;
}
}
{
private HashMap<String, String> cache = new HashMap<String, String>();
- public CommandRizonTime(Plugin pkg)
+ CommandRizonTime()
{
- super(pkg, "!RIZONTIME", "Calculates out a length of time in Rizon Time(tm)");
+ super("!RIZONTIME", "Calculates out a length of time in Rizon Time(tm)");
}
@Override
package net.rizon.moo.plugin.fun;
import com.google.common.eventbus.Subscribe;
+import com.google.inject.Inject;
import java.util.HashMap;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
import net.rizon.moo.Moo;
+import net.rizon.moo.events.EventListener;
import net.rizon.moo.events.EventPrivmsg;
import net.rizon.moo.events.EventQuit;
+import net.rizon.moo.irc.Protocol;
class TimedKill implements Runnable
{
+ private Protocol protocol;
private String dest, reason;
- public TimedKill(final String dest, final String reason)
+ public TimedKill(Protocol protocol, String dest, String reason)
{
+ this.protocol = protocol;
this.dest = dest;
this.reason = reason;
}
@Override
public void run()
{
- Moo.kill(this.dest, this.reason);
+ protocol.kill(this.dest, this.reason);
}
}
-class EventFun
+class EventFun implements EventListener
{
private static final Pattern killPattern = Pattern.compile("Killed \\(([^ ]*) \\(([^)]*)\\)\\)");
welcome = new HashMap<String, Integer>(),
gratz = new HashMap<String, Integer>();
+ @Inject
+ private Protocol protocol;
+
@Subscribe
public void onPrivmsg(EventPrivmsg evt)
{
String message = evt.getMessage(), source = evt.getSource(), channel = evt.getChannel();
if (message.startsWith("\1ACTION pets " + Moo.me.getNick()))
- Moo.privmsg(channel, "\1ACTION moos\1");
+ protocol.privmsg(channel, "\1ACTION moos\1");
else if (message.startsWith("\1ACTION milks " + Moo.me.getNick()))
{
int e = source.indexOf('!');
String nick = source.substring(0, e != -1 ? e : source.length());
- Moo.privmsg(channel, "\1ACTION kicks " + nick + " in the face\1");
+ protocol.privmsg(channel, "\1ACTION kicks " + nick + " in the face\1");
}
else if (message.startsWith("\1ACTION feeds " + Moo.me.getNick()))
- Moo.privmsg(channel, "\1ACTION eats happily\1");
+ protocol.privmsg(channel, "\1ACTION eats happily\1");
else if (message.startsWith("\1ACTION kicks " + Moo.me.getNick()))
{
int e = source.indexOf('!');
String nick = source.substring(0, e != -1 ? e : source.length());
- Moo.privmsg(channel, "\1ACTION body slams " + nick + "\1");
+ protocol.privmsg(channel, "\1ACTION body slams " + nick + "\1");
}
else if (message.startsWith("\1ACTION brands " + Moo.me.getNick()))
{
boolean kill = new Random().nextInt(100) == 0;
if (kill == false)
- Moo.privmsg(channel, "\1ACTION headbutts " + nick + " and proceeds to stomp on their lifeless body\1");
+ protocol.privmsg(channel, "\1ACTION headbutts " + nick + " and proceeds to stomp on their lifeless body\1");
else
{
- Moo.privmsg(channel, "FEEL THE WRATH OF " + Moo.me.getNick().toUpperCase());
- Moo.kill(nick, "HOW DARE YOU ATTEMPT TO BRAND " + Moo.me.getNick().toUpperCase());
+ protocol.privmsg(channel, "FEEL THE WRATH OF " + Moo.me.getNick().toUpperCase());
+ protocol.kill(nick, "HOW DARE YOU ATTEMPT TO BRAND " + Moo.me.getNick().toUpperCase());
}
}
else if (message.startsWith("\1ACTION tips " + Moo.me.getNick()))
{
int e = source.indexOf('!');
String nick = source.substring(0, e != -1 ? e : source.length());
- Moo.privmsg(channel, "\1ACTION inadvertently falls on " + nick + " and crushes them\1");
+ protocol.privmsg(channel, "\1ACTION inadvertently falls on " + nick + " and crushes them\1");
}
else if (message.startsWith("\1ACTION slaughters " + Moo.me.getNick()))
{
int e = source.indexOf('!');
String nick = source.substring(0, e != -1 ? e : source.length());
- Moo.privmsg(channel, "\1ACTION runs " + nick + " through a food processor and proceeds to eat them\1");
+ protocol.privmsg(channel, "\1ACTION runs " + nick + " through a food processor and proceeds to eat them\1");
}
}
if (r.nextBoolean())
my_kill_reason = my_kill_reason.toUpperCase();
- Moo.schedule(new TimedKill(killee, my_kill_reason), new Random().nextInt(250) + 60, TimeUnit.SECONDS);
+ Moo.schedule(new TimedKill(protocol, killee, my_kill_reason), new Random().nextInt(250) + 60, TimeUnit.SECONDS);
}
}
else if (kill_reason.toLowerCase().indexOf("welcome") > -1)
if (r.nextBoolean())
my_kill_reason = my_kill_reason.toUpperCase();
- Moo.schedule(new TimedKill(killee, my_kill_reason), new Random().nextInt(250) + 60, TimeUnit.SECONDS);
+ Moo.schedule(new TimedKill(protocol, killee, my_kill_reason), new Random().nextInt(250) + 60, TimeUnit.SECONDS);
}
}
else if (kill_reason.toLowerCase().indexOf("congrat") > -1 || kill_reason.toLowerCase().indexOf("gratz") > -1)
if (r.nextBoolean())
my_kill_reason = my_kill_reason.toUpperCase();
- Moo.schedule(new TimedKill(killee, my_kill_reason), new Random().nextInt(250) + 60, TimeUnit.SECONDS);
+ Moo.schedule(new TimedKill(protocol, killee, my_kill_reason), new Random().nextInt(250) + 60, TimeUnit.SECONDS);
}
}
}
package net.rizon.moo.plugin.fun;
+import com.google.inject.Inject;
+import com.google.inject.multibindings.Multibinder;
+import java.util.Arrays;
+import java.util.List;
import net.rizon.moo.Command;
-import net.rizon.moo.Moo;
import net.rizon.moo.Plugin;
-import net.rizon.moo.conf.Protocol;
+import net.rizon.moo.events.EventListener;
-public class fun extends Plugin
+public class fun extends Plugin implements EventListener
{
- private Command rt;
- private EventFun e;
+ @Inject
+ private CommandRizonTime rizonTime;
public fun() throws Exception
{
@Override
public void start() throws Exception
{
- if (Moo.conf.general.protocol == Protocol.PLEXUS)
- {
- rt = new CommandRizonTime(this);
- e = new EventFun();
- Moo.getEventBus().register(e);
- }
}
@Override
public void stop()
{
- if (rt != null)
- rt.remove();
- if (e != null)
- Moo.getEventBus().unregister(e);
+ // rt.remove();
+ }
+
+ @Override
+ protected void configure()
+ {
+ bind(fun.class).toInstance(this);
+
+ Multibinder<Command> commandBinder = Multibinder.newSetBinder(binder(), Command.class);
+ commandBinder.addBinding().to(CommandRizonTime.class);
+
+ Multibinder<EventListener> eventListenerBinder = Multibinder.newSetBinder(binder(), EventListener.class);
+ eventListenerBinder.addBinding().toInstance(this);
+ eventListenerBinder.addBinding().to(EventFun.class);
+ }
+
+ @Override
+ public List<Command> getCommands()
+ {
+ return Arrays.<Command>asList(rizonTime);
}
}
\ No newline at end of file
package net.rizon.moo;
import java.util.ArrayList;
+import java.util.List;
public abstract class Command
{
private Plugin pkg;
private String cmdname;
private String description;
- private ArrayList<String> channels = new ArrayList<String>();
+ private List<String> channels = new ArrayList<>();
public Command(Plugin pkg, final String cmdname, final String desc)
{
this.cmdname = cmdname;
this.description = desc;
- pkg.commands.add(this);
+ //pkg.commands.add(this);
+ }
+
+ public Command(String cmdname, String description)
+ {
+ this.cmdname = cmdname;
+ this.description = description;
}
- //@Override
public void remove()
{
- pkg.commands.remove(this);
- //super.remove();
+ //pkg.commands.remove(this);
}
public Plugin getPackage()
package net.rizon.moo;
+import com.google.inject.Inject;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
+import net.rizon.moo.conf.Config;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
public class Mail
{
- public static void send(final String to, final String subject, final String message)
+ @Inject
+ private Config conf;
+
+ public void send(final String to, final String subject, final String message)
{
- String smpath = Moo.conf.mail.path;
+ String smpath = conf.mail.path;
File sendmail = new File(smpath);
if (sendmail.isFile() == false)
public void run(IRCMessage message)
{
for (Message m : messages)
- {
if (m.getName().equalsIgnoreCase(message.getCommand()))
m.run(message);
- }
}
}
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
import org.slf4j.LoggerFactory;
import org.slf4j.Logger;
private static final Logger logger = LoggerFactory.getLogger(Moo.class);
private static final Date created = new Date();
- private EventLoopGroup group = new NioEventLoopGroup(1);
+ private final EventLoopGroup group = new NioEventLoopGroup(1);
public static io.netty.channel.Channel channel;
- public static Config conf = null;
+ private Config conf;
public static Database db = null;
public static boolean quitting = false;
moo.start();
}
- // Don't allow guice to JIT bind Moo
- private Moo()
+ public Config getConf()
{
+ return conf;
+ }
+
+ public void setConf(Config conf)
+ {
+ this.conf = conf;
}
private void run() throws InterruptedException
}
}
+ logger.info("moo v{} starting up", Version.getFullVersion());
+
this.rebuildInjector();
-// List<Module> modules = new ArrayList<>();
-// for (Plugin p : Plugin.getPlugins())
-// modules.add(p);
-// modules.add(new MooModule());
-// modules.add(new NettyModule());
-// modules.add(new Plexus());
-//
-// injector = Guice.createInjector(modules);
-//
-// injector.injectMembers(this);
- logger.info("moo v{} starting up", Version.getFullVersion());
+ eventManager.build();
eventBus.post(new InitDatabases());
eventBus.post(new LoadDatabases());
-
+
scheduleWithFixedDelay(databaseTimer, 5, TimeUnit.MINUTES);
while (quitting == false)
return moo.group.schedule(r, t, unit);
}
- private void rebuildInjector()
+ public void rebuildInjector()
{
+ for (Plugin p : Plugin.getPlugins())
+ p.stop();
+
List<Module> modules = new ArrayList<>();
- modules.add(new MooModule());
+ modules.add(new MooModule(this));
modules.add(new NettyModule());
modules.add(new Plexus());
eventManager.build();
- // XXX these are scheduler stuff here
+ for (Plugin p : Plugin.getPlugins())
+ try
+ {
+ p.start();
+ }
+ catch (Exception ex)
+ {
+ logger.warn("unable to start plugin " + p.getName(), ex);
+ }
}
}
import com.google.inject.Provides;
import com.google.inject.matcher.Matchers;
import com.google.inject.multibindings.Multibinder;
+import net.rizon.moo.conf.Config;
import net.rizon.moo.events.EventListener;
import net.rizon.moo.injectors.logger.LogTypeListener;
import net.rizon.moo.irc.IRC;
public class MooModule extends AbstractModule
{
private static IRC irc = new IRC();
+ private static ServerManager serverManager = new ServerManager();
+
+ private Moo moo;
+
+ MooModule(Moo moo)
+ {
+ this.moo = moo;
+ }
@Override
protected void configure()
{
+ bind(Moo.class).toInstance(moo);
+ bind(Mail.class);
+
bind(EventBus.class).toInstance(new EventBus());
bind(CommandManager.class).toInstance(new CommandManager());
bind(MessageManager.class).toInstance(new MessageManager());
bind(EventManager.class).toInstance(new EventManager());
- bind(ServerManager.class).toInstance(new ServerManager());
+ bind(ServerManager.class).toInstance(serverManager);
bind(DatabaseTimer.class).toInstance(new DatabaseTimer());
bindListener(Matchers.any(), new LogTypeListener());
Multibinder<EventListener> eventListenerBinder = Multibinder.newSetBinder(binder(), EventListener.class);
eventListenerBinder.addBinding().to(ServerManager.class);
}
+
+ @Provides
+ Config provideConfig()
+ {
+ return moo.getConf();
+ }
@Provides
IRC provideIRC()
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.LinkedList;
+import java.util.List;
public abstract class Plugin extends AbstractModule
{
private String name, desc;
public String pname;
protected ClassLoader loader; // Loader for this plugin
- public LinkedList<Command> commands = new LinkedList<Command>();
+ //public List<Command> commands = new LinkedList<>();
protected Plugin(String name, String desc)
{
public abstract void start() throws Exception;
public abstract void stop();
+ public abstract List<Command> getCommands();
+
//@SuppressWarnings("resource")
private static Plugin loadPlugin(String base, String name, boolean core) throws Throwable
{
p.pname = name;
p.loader = cl;
- p.start();
return p;
}
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;
import net.rizon.moo.Moo;
+import net.rizon.moo.conf.Config;
public class ClientInitializer extends ChannelInitializer<SocketChannel>
{
private LoggingHandler loggingHandler;
@Inject
- private ClientHandler clientHandler;
+ private ClientHandler clientHandler;
+
+ @Inject
+ private Config conf;
@Override
protected void initChannel(SocketChannel ch) throws Exception
{
ChannelPipeline pipeline = ch.pipeline();
- if (Moo.conf.general.ssl)
+ if (conf.general.ssl)
{
SslContext sslCtx;
- if (Moo.conf.general.cert != null && Moo.conf.general.key != null)
+ if (conf.general.cert != null && conf.general.key != null)
{
CertificateFactory certFactory = CertificateFactory.getInstance("X.509");
- byte[] certBytes = Files.readAllBytes(new File(Moo.conf.general.cert).toPath());
- byte[] keyBytes = Files.readAllBytes(new File(Moo.conf.general.key).toPath());
+ byte[] certBytes = Files.readAllBytes(new File(conf.general.cert).toPath());
+ byte[] keyBytes = Files.readAllBytes(new File(conf.general.key).toPath());
X509Certificate cert = (X509Certificate) certFactory.generateCertificate(new ByteArrayInputStream(certBytes));
PrivateKey key = (PrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(keyBytes));
public class NettyModule extends AbstractModule
{
+ // Only allow one client handler, since netty calls back into this. We need to
+ // update the injections into it
+ private static final ClientHandler handler = new ClientHandler();
+
@Override
protected void configure()
{
bind(ClientInitializer.class);
bind(Handler.class);
bind(LoggingHandler.class);
- bind(ClientHandler.class);
+ bind(ClientHandler.class).toInstance(handler);
bind(Channel.class).toProvider(ChannelProvider.class);
}
}
import java.util.EnumSet;
import net.rizon.moo.Moo;
import static net.rizon.moo.Moo.akillServ;
-import static net.rizon.moo.Moo.conf;
+import net.rizon.moo.conf.Config;
import net.rizon.moo.io.IRCMessage;
public class Protocol
{
@Inject
private Provider<io.netty.channel.Channel> channelProvider;
+
+ @Inject
+ private Config conf;
public void write(String command, Object... args)
{
public void reply(String source, String target, String buffer)
{
- if (target.equalsIgnoreCase(Moo.conf.general.nick))
+ if (target.equalsIgnoreCase(conf.general.nick))
notice(source, buffer);
else
privmsg(target, buffer);
@Override
public FilterReply decide(ILoggingEvent event)
{
- boolean show = Moo.conf.debug || event.getLevel() != Level.DEBUG;
- return show ? FilterReply.ACCEPT : FilterReply.DENY;
+ //boolean show = Moo.conf.debug || event.getLevel() != Level.DEBUG;
+ //return show ? FilterReply.ACCEPT : FilterReply.DENY;
+ return FilterReply.ACCEPT;
}
}
Level level = event.getLevel();
boolean bad = level == Level.ERROR || level == Level.WARN || level == Level.ALL;
- if (Moo.conf != null)
- if (level == Level.INFO || bad)
- for (final String ch : Moo.conf.moo_log_channels)
+// if (Moo.conf != null)
+// if (level == Level.INFO || bad)
+// for (final String ch : Moo.conf.moo_log_channels)
{
// if (message != null)
// Moo.privmsg(ch, message); // XXX logback makes this so can't really inject? post event? cant get eventbus.
import com.google.inject.Inject;
import net.rizon.moo.Message;
import net.rizon.moo.Moo;
+import net.rizon.moo.conf.Config;
import net.rizon.moo.irc.Server;
import net.rizon.moo.irc.User;
import net.rizon.moo.events.OnConnect;
@Inject
private ServerManager serverManager;
+
+ @Inject
+ private Config conf;
public Message001()
{
@Override
public void run(IRCMessage message)
{
- if (Moo.conf.general.oper != null)
- protocol.write("OPER", Moo.conf.general.oper.name, Moo.conf.general.oper.pass);
- if (Moo.conf.general.nickserv != null)
- protocol.privmsg("NickServ", "IDENTIFY " + Moo.conf.general.nickserv.pass);
+ if (conf.general.oper != null)
+ protocol.write("OPER", conf.general.oper.name, conf.general.oper.pass);
+ if (conf.general.nickserv != null)
+ protocol.privmsg("NickServ", "IDENTIFY " + conf.general.nickserv.pass);
- Moo.me = new User(Moo.conf.general.nick);
+ Moo.me = new User(conf.general.nick);
irc.insertUser(Moo.me);
- for (String s : Moo.conf.channels)
+ for (String s : conf.channels)
protocol.join(s);
protocol.write("MAP");
import com.google.inject.Inject;
import net.rizon.moo.Message;
import net.rizon.moo.Moo;
+import net.rizon.moo.conf.Config;
import net.rizon.moo.io.IRCMessage;
import net.rizon.moo.irc.Protocol;
{
@Inject
private Protocol protocol;
+
+ @Inject
+ private Config conf;
public MessageInvite()
{
public void run(IRCMessage message)
{
if (message.getParams().length > 1 && message.getParams()[0].equalsIgnoreCase(Moo.me.getNick()))
- if (Moo.conf.channelsContains(message.getParams()[1]))
+ if (conf.channelsContains(message.getParams()[1]))
protocol.join(message.getParams()[1]);
}
}
\ No newline at end of file
import net.rizon.moo.Message;
import net.rizon.moo.Moo;
+import net.rizon.moo.conf.Config;
import net.rizon.moo.events.EventClientConnect;
import net.rizon.moo.events.EventNotice;
import net.rizon.moo.events.OnServerLink;
@Inject
private ServerManager serverManager;
+ @Inject
+ private Config conf;
+
public MessageNotice()
{
super("NOTICE");
// XXX this should be in a plugin
private void process(String source, String message)
{
- if (Moo.conf.general.nickserv != null && source.equals(Moo.conf.general.nickserv.mask))
+ if (conf.general.nickserv != null && source.equals(conf.general.nickserv.mask))
{
if (message.contains("This nickname is registered"))
- protocol.privmsg(source, "IDENTIFY " + Moo.conf.general.nickserv.pass);
+ protocol.privmsg(source, "IDENTIFY " + conf.general.nickserv.pass);
}
else if (source.indexOf('@') == -1)
{
import net.rizon.moo.Message;
import net.rizon.moo.Moo;
+import net.rizon.moo.conf.Config;
import net.rizon.moo.events.EventPrivmsg;
import net.rizon.moo.io.IRCMessage;
import net.rizon.moo.irc.Protocol;
@Inject
private CommandManager manager;
+
+ @Inject
+ private Config conf;
public MessagePrivmsg()
{
eventBus.post(new EventPrivmsg(message.getSource(), target, text));
if (text.equals("\1VERSION\1"))
- protocol.notice(message.getNick(), "\1VERSION " + Moo.conf.version + "\1");
+ protocol.notice(message.getNick(), "\1VERSION " + conf.version + "\1");
else if (text.equals("\1TIME\1"))
protocol.notice(message.getNick(), "\1TIME " + (new Date().toString()) + "\1");
<module>commands</module>
<module>commits</module>-->
<module>core</module>
-<!-- <module>dnsbl</module>
- <module>dnsblstats</module>
+ <module>dnsbl</module>
+<!-- <module>dnsblstats</module>-->
<module>fun</module>
- <module>grapher</module>
+<!-- <module>grapher</module>
<module>logging</module>
<module>mxbl</module>
<module>osflood</module>
projects / irc / rizon / moo.git / commitdiff
