From 16d0b5c228dd8d981a0d79944c70248ea813d63b Mon Sep 17 00:00:00 2001 From: ementalo Date: Wed, 27 Jun 2012 13:35:39 +0100 Subject: package name change to net.ess3 --- .../src/net/ess3/xmpp/Commandsetxmpp.java | 21 ++ EssentialsXMPP/src/net/ess3/xmpp/Commandxmpp.java | 36 ++ .../src/net/ess3/xmpp/Commandxmppspy.java | 40 +++ .../src/net/ess3/xmpp/EssentialsXMPP.java | 150 +++++++++ .../ess3/xmpp/EssentialsXMPPPlayerListener.java | 58 ++++ .../src/net/ess3/xmpp/IEssentialsXMPP.java | 28 ++ EssentialsXMPP/src/net/ess3/xmpp/UserManager.java | 100 ++++++ EssentialsXMPP/src/net/ess3/xmpp/XMPPManager.java | 375 +++++++++++++++++++++ 8 files changed, 808 insertions(+) create mode 100644 EssentialsXMPP/src/net/ess3/xmpp/Commandsetxmpp.java create mode 100644 EssentialsXMPP/src/net/ess3/xmpp/Commandxmpp.java create mode 100644 EssentialsXMPP/src/net/ess3/xmpp/Commandxmppspy.java create mode 100644 EssentialsXMPP/src/net/ess3/xmpp/EssentialsXMPP.java create mode 100644 EssentialsXMPP/src/net/ess3/xmpp/EssentialsXMPPPlayerListener.java create mode 100644 EssentialsXMPP/src/net/ess3/xmpp/IEssentialsXMPP.java create mode 100644 EssentialsXMPP/src/net/ess3/xmpp/UserManager.java create mode 100644 EssentialsXMPP/src/net/ess3/xmpp/XMPPManager.java (limited to 'EssentialsXMPP/src/net/ess3') diff --git a/EssentialsXMPP/src/net/ess3/xmpp/Commandsetxmpp.java b/EssentialsXMPP/src/net/ess3/xmpp/Commandsetxmpp.java new file mode 100644 index 000000000..57bee3b58 --- /dev/null +++ b/EssentialsXMPP/src/net/ess3/xmpp/Commandsetxmpp.java @@ -0,0 +1,21 @@ +package net.ess3.xmpp; + +import net.ess3.api.IUser; +import net.ess3.commands.EssentialsCommand; +import net.ess3.commands.NotEnoughArgumentsException; + + +public class Commandsetxmpp extends EssentialsCommand +{ + @Override + protected void run(final IUser user, final String commandLabel, final String[] args) throws NotEnoughArgumentsException + { + if (args.length < 1) + { + throw new NotEnoughArgumentsException(); + } + + EssentialsXMPP.getInstance().setAddress(user, args[0]); + user.sendMessage("XMPP address set to " + args[0]); + } +} diff --git a/EssentialsXMPP/src/net/ess3/xmpp/Commandxmpp.java b/EssentialsXMPP/src/net/ess3/xmpp/Commandxmpp.java new file mode 100644 index 000000000..854a91d96 --- /dev/null +++ b/EssentialsXMPP/src/net/ess3/xmpp/Commandxmpp.java @@ -0,0 +1,36 @@ +package net.ess3.xmpp; + +import net.ess3.Console; +import net.ess3.commands.EssentialsCommand; +import net.ess3.commands.NotEnoughArgumentsException; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + + +public class Commandxmpp extends EssentialsCommand +{ + @Override + protected void run(final CommandSender sender, final String commandLabel, final String[] args) throws NotEnoughArgumentsException + { + if (args.length < 2) + { + throw new NotEnoughArgumentsException(); + } + + final String address = EssentialsXMPP.getInstance().getAddress(args[0]); + if (address == null) + { + sender.sendMessage("§cThere are no players matching that name."); + } + else + { + final String message = getFinalArg(args, 1); + final String senderName = sender instanceof Player ? ess.getUser((Player)sender).getDisplayName() : Console.NAME; + sender.sendMessage("[" + senderName + ">" + address + "] " + message); + if (!EssentialsXMPP.getInstance().sendMessage(address, "[" + senderName + "] " + message)) + { + sender.sendMessage("§cError sending message."); + } + } + } +} diff --git a/EssentialsXMPP/src/net/ess3/xmpp/Commandxmppspy.java b/EssentialsXMPP/src/net/ess3/xmpp/Commandxmppspy.java new file mode 100644 index 000000000..0c59910f4 --- /dev/null +++ b/EssentialsXMPP/src/net/ess3/xmpp/Commandxmppspy.java @@ -0,0 +1,40 @@ +package net.ess3.xmpp; + +import net.ess3.commands.EssentialsCommand; +import net.ess3.commands.NotEnoughArgumentsException; +import java.util.List; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + + +public class Commandxmppspy extends EssentialsCommand +{ + @Override + protected void run(final CommandSender sender, final String commandLabel, final String[] args) throws NotEnoughArgumentsException + { + if (args.length < 1) + { + throw new NotEnoughArgumentsException(); + } + + final List matches = server.matchPlayer(args[0]); + + if (matches.isEmpty()) + { + sender.sendMessage("§cThere are no players matching that name."); + } + + for (Player p : matches) + { + try + { + final boolean toggle = EssentialsXMPP.getInstance().toggleSpy(p); + sender.sendMessage("XMPP Spy " + (toggle ? "enabled" : "disabled") + " for " + p.getDisplayName()); + } + catch (Exception ex) + { + sender.sendMessage("Error: " + ex.getMessage()); + } + } + } +} diff --git a/EssentialsXMPP/src/net/ess3/xmpp/EssentialsXMPP.java b/EssentialsXMPP/src/net/ess3/xmpp/EssentialsXMPP.java new file mode 100644 index 000000000..74ab09fd5 --- /dev/null +++ b/EssentialsXMPP/src/net/ess3/xmpp/EssentialsXMPP.java @@ -0,0 +1,150 @@ +package net.ess3.xmpp; + +import static net.ess3.I18n._; +import net.ess3.api.ICommandHandler; +import net.ess3.api.IEssentials; +import net.ess3.api.IUser; +import net.ess3.commands.EssentialsCommandHandler; +import java.util.List; +import java.util.Locale; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; +import org.bukkit.plugin.PluginManager; +import org.bukkit.plugin.java.JavaPlugin; + + +public class EssentialsXMPP extends JavaPlugin implements IEssentialsXMPP +{ + private static final Logger LOGGER = Logger.getLogger("Minecraft"); + private static EssentialsXMPP instance = null; + private transient UserManager users; + private transient XMPPManager xmpp; + private transient IEssentials ess; + private transient ICommandHandler commandHandler; + + public static IEssentialsXMPP getInstance() + { + return instance; + } + + @Override + public void onEnable() + { + instance = this; + + final PluginManager pluginManager = getServer().getPluginManager(); + ess = (IEssentials)pluginManager.getPlugin("Essentials-3"); + if (!this.getDescription().getVersion().equals(ess.getDescription().getVersion())) + { + LOGGER.log(Level.WARNING, _("versionMismatchAll")); + } + if (!ess.isEnabled()) + { + this.setEnabled(false); + return; + } + + final EssentialsXMPPPlayerListener playerListener = new EssentialsXMPPPlayerListener(ess); + pluginManager.registerEvents(playerListener, this); + + users = new UserManager(this.getDataFolder()); + xmpp = new XMPPManager(this); + + ess.addReloadListener(users); + ess.addReloadListener(xmpp); + + commandHandler = new EssentialsCommandHandler(EssentialsXMPP.class.getClassLoader(), "net.ess3.xmpp.Command", "essentials.", ess); + } + + @Override + public void onDisable() + { + if (xmpp != null) + { + xmpp.disconnect(); + } + instance = null; + } + + @Override + public boolean onCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] args) + { + return commandHandler.handleCommand(sender, command, commandLabel, args); + } + + @Override + public void setAddress(final Player user, final String address) + { + final String username = user.getName().toLowerCase(Locale.ENGLISH); + instance.users.setAddress(username, address); + } + + @Override + public String getAddress(final String name) + { + return instance.users.getAddress(name); + } + + @Override + public IUser getUserByAddress(final String address) + { + String username = instance.users.getUserByAddress(address); + return username == null ? null : ess.getUser(username); + } + + @Override + public boolean toggleSpy(final Player user) + { + final String username = user.getName().toLowerCase(Locale.ENGLISH); + final boolean spy = !instance.users.isSpy(username); + instance.users.setSpy(username, spy); + return spy; + } + + @Override + public String getAddress(final Player user) + { + return instance.users.getAddress(user.getName()); + } + + @Override + public boolean sendMessage(final Player user, final String message) + { + return instance.xmpp.sendMessage(instance.users.getAddress(user.getName()), message); + } + + @Override + public boolean sendMessage(final String address, final String message) + { + return instance.xmpp.sendMessage(address, message); + } + + @Override + public List getSpyUsers() + { + return instance.users.getSpyUsers(); + } + + @Override + public void broadcastMessage(final IUser sender, final String message, final String xmppAddress) + { + ess.broadcastMessage(sender, message); + try + { + for (String address : getSpyUsers()) + { + if (!address.equalsIgnoreCase(xmppAddress)) + { + sendMessage(address, message); + } + } + } + catch (Exception ex) + { + // Ignore exceptions + } + } +} diff --git a/EssentialsXMPP/src/net/ess3/xmpp/EssentialsXMPPPlayerListener.java b/EssentialsXMPP/src/net/ess3/xmpp/EssentialsXMPPPlayerListener.java new file mode 100644 index 000000000..4880aead7 --- /dev/null +++ b/EssentialsXMPP/src/net/ess3/xmpp/EssentialsXMPPPlayerListener.java @@ -0,0 +1,58 @@ +package net.ess3.xmpp; + +import net.ess3.api.IEssentials; +import net.ess3.api.IUser; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerChatEvent; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.PlayerQuitEvent; + + +class EssentialsXMPPPlayerListener implements Listener +{ + private final transient IEssentials ess; + + EssentialsXMPPPlayerListener(final IEssentials ess) + { + super(); + this.ess = ess; + } + + @EventHandler(priority= EventPriority.MONITOR) + public void onPlayerJoin(final PlayerJoinEvent event) + { + final IUser user = ess.getUser(event.getPlayer()); + sendMessageToSpyUsers("Player " + user.getDisplayName() + " joined the game"); + } + + @EventHandler(priority= EventPriority.MONITOR) + public void onPlayerChat(final PlayerChatEvent event) + { + final IUser user = ess.getUser(event.getPlayer()); + sendMessageToSpyUsers(String.format(event.getFormat(), user.getDisplayName(), event.getMessage())); + } + + @EventHandler(priority= EventPriority.MONITOR) + public void onPlayerQuit(final PlayerQuitEvent event) + { + final IUser user = ess.getUser(event.getPlayer()); + sendMessageToSpyUsers("Player " + user.getDisplayName() + " left the game"); + } + + private void sendMessageToSpyUsers(final String message) + { + try + { + for (String address : EssentialsXMPP.getInstance().getSpyUsers()) + { + EssentialsXMPP.getInstance().sendMessage(address, message); + } + } + catch (Exception ex) + { + // Ignore exceptions + } + } +} diff --git a/EssentialsXMPP/src/net/ess3/xmpp/IEssentialsXMPP.java b/EssentialsXMPP/src/net/ess3/xmpp/IEssentialsXMPP.java new file mode 100644 index 000000000..373a7879d --- /dev/null +++ b/EssentialsXMPP/src/net/ess3/xmpp/IEssentialsXMPP.java @@ -0,0 +1,28 @@ +package net.ess3.xmpp; + +import net.ess3.api.IUser; +import java.util.List; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + + +public interface IEssentialsXMPP extends Plugin +{ + String getAddress(final Player user); + + String getAddress(final String name); + + List getSpyUsers(); + + IUser getUserByAddress(final String address); + + boolean sendMessage(final Player user, final String message); + + boolean sendMessage(final String address, final String message); + + void setAddress(final Player user, final String address); + + boolean toggleSpy(final Player user); + + void broadcastMessage(final IUser sender, final String message, final String xmppAddress); +} diff --git a/EssentialsXMPP/src/net/ess3/xmpp/UserManager.java b/EssentialsXMPP/src/net/ess3/xmpp/UserManager.java new file mode 100644 index 000000000..a2018c006 --- /dev/null +++ b/EssentialsXMPP/src/net/ess3/xmpp/UserManager.java @@ -0,0 +1,100 @@ +package net.ess3.xmpp; + +import net.ess3.api.IReload; +import java.io.File; +import java.io.IOException; +import java.util.*; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.bukkit.configuration.file.YamlConfiguration; + + +public class UserManager implements IReload +{ + private transient YamlConfiguration users; + private final transient File folder; + private final transient List spyusers = new ArrayList(); + private final static String ADDRESS = "address"; + private final static String SPY = "spy"; + + public UserManager(final File folder) + { + this.folder = folder; + onReload(); + } + + public final boolean isSpy(final String username) + { + return users.getBoolean(username.toLowerCase(Locale.ENGLISH) + "." + SPY, false); + } + + public void setSpy(final String username, final boolean spy) + { + setUser(username.toLowerCase(Locale.ENGLISH), getAddress(username), spy); + } + + public final String getAddress(final String username) + { + return users.getString(username.toLowerCase(Locale.ENGLISH) + "." + ADDRESS, null); + } + + public final String getUserByAddress(final String search) + { + final Set usernames = users.getKeys(false); + for (String username : usernames) + { + final String address = users.getString(username + "." + ADDRESS, null); + if (address != null && search.equalsIgnoreCase(address)) + { + return username; + } + } + return null; + } + + public void setAddress(final String username, final String address) + { + setUser(username.toLowerCase(Locale.ENGLISH), address, isSpy(username)); + } + + public List getSpyUsers() + { + return spyusers; + } + + private void setUser(final String username, final String address, final boolean spy) + { + final Map userdata = new HashMap(); + userdata.put(ADDRESS, address); + userdata.put(SPY, spy); + users.set(username, userdata); + try + { + users.save(new File(folder, "users.yml")); + } + catch (IOException ex) + { + Logger.getLogger(UserManager.class.getName()).log(Level.SEVERE, null, ex); + } + onReload(); + } + + @Override + public final void onReload() + { + users = YamlConfiguration.loadConfiguration(new File(folder, "users.yml")); + spyusers.clear(); + final Set keys = users.getKeys(false); + for (String key : keys) + { + if (isSpy(key)) + { + final String address = getAddress(key); + if (address != null) + { + spyusers.add(address); + } + } + } + } +} diff --git a/EssentialsXMPP/src/net/ess3/xmpp/XMPPManager.java b/EssentialsXMPP/src/net/ess3/xmpp/XMPPManager.java new file mode 100644 index 000000000..ff49bc931 --- /dev/null +++ b/EssentialsXMPP/src/net/ess3/xmpp/XMPPManager.java @@ -0,0 +1,375 @@ +package net.ess3.xmpp; + +import net.ess3.api.IReload; +import net.ess3.api.IUser; +import net.ess3.utils.Util; +import java.io.File; +import java.util.*; +import java.util.logging.Handler; +import java.util.logging.Level; +import java.util.logging.LogRecord; +import java.util.logging.Logger; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.jivesoftware.smack.*; +import org.jivesoftware.smack.Roster.SubscriptionMode; +import org.jivesoftware.smack.packet.Message; +import org.jivesoftware.smack.packet.Presence; +import org.jivesoftware.smack.util.StringUtils; + + +public final class XMPPManager extends Handler implements MessageListener, ChatManagerListener, IReload +{ + private static final Logger LOGGER = Logger.getLogger("Minecraft"); + private transient YamlConfiguration config = null; + private transient XMPPConnection connection; + private transient ChatManager chatManager; + private final transient Map chats = Collections.synchronizedMap(new HashMap()); + private final transient Set logrecords = Collections.synchronizedSet(new HashSet()); + private final transient IEssentialsXMPP parent; + private transient List logUsers; + private transient Level logLevel; + private transient boolean ignoreLagMessages = true; + private transient Thread loggerThread; + private transient boolean threadrunning = true; + + public XMPPManager(final IEssentialsXMPP parent) + { + super(); + this.parent = parent; + // config.setTemplateName("/config.yml", EssentialsXMPP.class); + onReload(); + } + + public boolean sendMessage(final String address, final String message) + { + if (address != null && !address.isEmpty()) + { + try + { + startChat(address); + final Chat chat; + synchronized (chats) + { + chat = chats.get(address); + } + if (chat != null) + { + if (!connection.isConnected()) + { + disconnect(); + connect(); + } + chat.sendMessage(Util.stripFormat(message)); + return true; + } + } + catch (XMPPException ex) + { + disableChat(address); + } + } + return false; + } + + @Override + public void processMessage(final Chat chat, final Message msg) + { + // Normally we should log the error message + // But we would create a loop if the connection to a log-user fails. + if (msg.getType() != Message.Type.error && msg.getBody().length() > 0) + { + final String message = msg.getBody(); + switch (message.charAt(0)) + { + case '@': + sendPrivateMessage(chat, message); + break; + case '/': + sendCommand(chat, message); + break; + default: + final IUser sender = parent.getUserByAddress(StringUtils.parseBareAddress(chat.getParticipant())); + parent.broadcastMessage(sender, "=" + sender.getDisplayName() + ": " + message, StringUtils.parseBareAddress(chat.getParticipant())); + } + } + } + + private boolean connect() + { + final String server = config.getString("xmpp.server"); + if (server == null || server.equals("example.com")) + { + LOGGER.log(Level.WARNING, "config broken for xmpp"); + return false; + } + final int port = config.getInt("xmpp.port", 5222); + final String serviceName = config.getString("xmpp.servicename", server); + final String xmppuser = config.getString("xmpp.user"); + final String password = config.getString("xmpp.password"); + final ConnectionConfiguration connConf = new ConnectionConfiguration(server, port, serviceName); + final StringBuilder stringBuilder = new StringBuilder(); + stringBuilder.append("Connecting to xmpp server ").append(server).append(":").append(port); + stringBuilder.append(" as user ").append(xmppuser).append("."); + LOGGER.log(Level.INFO, stringBuilder.toString()); + connConf.setSASLAuthenticationEnabled(config.getBoolean("xmpp.sasl-enabled", false)); + connConf.setSendPresence(true); + connConf.setReconnectionAllowed(true); + connection = new XMPPConnection(connConf); + try + { + connection.connect(); + connection.login(xmppuser, password); + connection.getRoster().setSubscriptionMode(SubscriptionMode.accept_all); + chatManager = connection.getChatManager(); + chatManager.addChatListener(this); + return true; + } + catch (XMPPException ex) + { + LOGGER.log(Level.WARNING, "Failed to connect to server: " + server, ex); + return false; + } + } + + public void disconnect() + { + if (loggerThread != null) + { + loggerThread.interrupt(); + } + if (chatManager != null) + { + chatManager.removeChatListener(this); + chatManager = null; + } + if (connection != null) + { + connection.disconnect(new Presence(Presence.Type.unavailable)); + } + + } + + @Override + public void chatCreated(final Chat chat, final boolean createdLocally) + { + if (!createdLocally) + { + chat.addMessageListener(this); + final Chat old = chats.put(StringUtils.parseBareAddress(chat.getParticipant()), chat); + if (old != null) + { + old.removeMessageListener(this); + } + } + } + + @Override + public void onReload() + { + LOGGER.removeHandler(this); + config = YamlConfiguration.loadConfiguration(new File(parent.getDataFolder(), "config.yml")); + synchronized (chats) + { + disconnect(); + chats.clear(); + if (!connect()) + { + return; + } + startLoggerThread(); + } + if (config.getBoolean("log-enabled", false)) + { + LOGGER.addHandler(this); + logUsers = config.getStringList("log-users"); + final String level = config.getString("log-level", "info"); + try + { + logLevel = Level.parse(level.toUpperCase(Locale.ENGLISH)); + } + catch (IllegalArgumentException e) + { + logLevel = Level.INFO; + } + ignoreLagMessages = config.getBoolean("ignore-lag-messages", true); + } + } + + @Override + public void publish(final LogRecord logRecord) + { + try + { + if (ignoreLagMessages && logRecord.getMessage().equals("Can't keep up! Did the system time change, or is the server overloaded?")) + { + return; + } + if (logRecord.getLevel().intValue() >= logLevel.intValue()) + { + synchronized (logrecords) + { + logrecords.add(logRecord); + } + } + } + catch (Exception e) + { + // Ignore all exceptions + // Otherwise we create a loop. + } + } + + @Override + public void flush() + { + // Ignore this + } + + @Override + public void close() throws SecurityException + { + // Ignore this + } + + private void startLoggerThread() + { + loggerThread = new Thread(new Runnable() + { + @Override + public void run() + { + final Set copy = new HashSet(); + final Set failedUsers = new HashSet(); + while (threadrunning) + { + synchronized (logrecords) + { + if (!logrecords.isEmpty()) + { + copy.addAll(logrecords); + logrecords.clear(); + } + } + if (!copy.isEmpty()) + { + for (String user : logUsers) + { + try + { + XMPPManager.this.startChat(user); + for (LogRecord logRecord : copy) + { + final String message = String.format("[" + logRecord.getLevel().getLocalizedName() + "] " + logRecord.getMessage(), logRecord.getParameters()); + if (!XMPPManager.this.sendMessage(user, message)) + { + failedUsers.add(user); + break; + } + + } + } + catch (XMPPException ex) + { + failedUsers.add(user); + LOGGER.removeHandler(XMPPManager.this); + LOGGER.log(Level.SEVERE, "Failed to deliver log message! Disabling logging to XMPP.", ex); + } + } + logUsers.removeAll(failedUsers); + if (logUsers.isEmpty()) + { + LOGGER.removeHandler(XMPPManager.this); + threadrunning = false; + } + copy.clear(); + } + try + { + Thread.sleep(2000); + } + catch (InterruptedException ex) + { + threadrunning = false; + } + } + LOGGER.removeHandler(XMPPManager.this); + } + }); + loggerThread.start(); + } + + private void startChat(final String address) throws XMPPException + { + if (chatManager == null) + { + return; + } + synchronized (chats) + { + if (!chats.containsKey(address)) + { + final Chat chat = chatManager.createChat(address, this); + if (chat == null) + { + throw new XMPPException("Could not start Chat with " + address); + } + chats.put(address, chat); + } + } + } + + private void sendPrivateMessage(final Chat chat, final String message) + { + final String[] parts = message.split(" ", 2); + if (parts.length == 2) + { + final List matches = parent.getServer().matchPlayer(parts[0].substring(1)); + + if (matches.isEmpty()) + { + try + { + chat.sendMessage("User " + parts[0] + " not found"); + } + catch (XMPPException ex) + { + LOGGER.log(Level.WARNING, "Failed to send xmpp message.", ex); + } + } + else + { + final String from = "[" + parent.getUserByAddress(StringUtils.parseBareAddress(chat.getParticipant())) + ">"; + for (Player p : matches) + { + p.sendMessage(from + p.getDisplayName() + "] " + message); + } + } + } + } + + private void sendCommand(final Chat chat, final String message) + { + if (config.getStringList("op-users").contains(StringUtils.parseBareAddress(chat.getParticipant()))) + { + try + { + parent.getServer().dispatchCommand(parent.getServer().getConsoleSender(), message.substring(1)); + } + catch (Exception ex) + { + LOGGER.log(Level.SEVERE, ex.getMessage(), ex); + } + } + } + + private void disableChat(final String address) + { + final Chat chat = chats.get(address); + if (chat != null) + { + chat.removeMessageListener(this); + chats.remove(address); + } + } +} -- cgit v1.2.3