355 lines
14 KiB
Java
355 lines
14 KiB
Java
package com.earth2me.essentials.xmpp;
|
|
|
|
import com.earth2me.essentials.Console;
|
|
import com.earth2me.essentials.IConf;
|
|
import com.earth2me.essentials.config.EssentialsConfiguration;
|
|
import com.earth2me.essentials.utils.AdventureUtil;
|
|
import com.earth2me.essentials.utils.FormatUtil;
|
|
import net.ess3.api.IUser;
|
|
import org.bukkit.entity.Player;
|
|
import org.jivesoftware.smack.Chat;
|
|
import org.jivesoftware.smack.ChatManager;
|
|
import org.jivesoftware.smack.ChatManagerListener;
|
|
import org.jivesoftware.smack.ConnectionConfiguration;
|
|
import org.jivesoftware.smack.MessageListener;
|
|
import org.jivesoftware.smack.Roster.SubscriptionMode;
|
|
import org.jivesoftware.smack.XMPPConnection;
|
|
import org.jivesoftware.smack.XMPPException;
|
|
import org.jivesoftware.smack.packet.Message;
|
|
import org.jivesoftware.smack.packet.Presence;
|
|
import org.jivesoftware.smack.util.StringUtils;
|
|
|
|
import java.io.File;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.logging.Handler;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.LogRecord;
|
|
import java.util.logging.Logger;
|
|
import java.util.logging.SimpleFormatter;
|
|
|
|
import static com.earth2me.essentials.I18n.tlLiteral;
|
|
|
|
public class XMPPManager extends Handler implements MessageListener, ChatManagerListener, IConf {
|
|
private static final Logger logger = EssentialsXMPP.getWrappedLogger();
|
|
private static final SimpleFormatter formatter = new SimpleFormatter();
|
|
private final transient EssentialsConfiguration config;
|
|
private final transient Map<String, Chat> chats = Collections.synchronizedMap(new HashMap<>());
|
|
private final transient Set<LogRecord> logrecords = Collections.synchronizedSet(new HashSet<>());
|
|
private final transient IEssentialsXMPP parent;
|
|
private transient XMPPConnection connection;
|
|
private transient ChatManager chatManager;
|
|
private transient List<String> logUsers;
|
|
private transient Level logLevel;
|
|
private transient boolean ignoreLagMessages = true;
|
|
private transient Thread loggerThread;
|
|
private transient boolean threadrunning = true;
|
|
|
|
XMPPManager(final IEssentialsXMPP parent) {
|
|
super();
|
|
this.parent = parent;
|
|
config = new EssentialsConfiguration(new File(parent.getDataFolder(), "config.yml"), "/config.yml", EssentialsXMPP.class);
|
|
reloadConfig();
|
|
}
|
|
|
|
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(FormatUtil.stripFormat(message));
|
|
return true;
|
|
}
|
|
} catch (final 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.getBase().getDisplayName() + ": " + message, StringUtils.parseBareAddress(chat.getParticipant()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean connect() {
|
|
final String server = config.getString("xmpp.server", null);
|
|
if (server == null || server.equals("example.com")) {
|
|
logger.log(Level.WARNING, tlLiteral("xmppNotConfigured"));
|
|
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", null);
|
|
final String password = config.getString("xmpp.password", null);
|
|
final boolean requireTLS = config.getBoolean("xmpp.require-server-tls", false);
|
|
final ConnectionConfiguration connConf = new ConnectionConfiguration(server, port, serviceName);
|
|
final String stringBuilder = "Connecting to xmpp server " + server + ":" + port + " as user " + xmppuser + ".";
|
|
logger.log(Level.INFO, stringBuilder);
|
|
connConf.setSASLAuthenticationEnabled(config.getBoolean("xmpp.sasl-enabled", false));
|
|
connConf.setSendPresence(true);
|
|
connConf.setReconnectionAllowed(true);
|
|
connConf.setDebuggerEnabled(config.getBoolean("debug", false));
|
|
if (requireTLS) {
|
|
// "enabled" (TLS optional) is the default
|
|
connConf.setSecurityMode(ConnectionConfiguration.SecurityMode.required);
|
|
}
|
|
connection = new XMPPConnection(connConf);
|
|
try {
|
|
connection.connect();
|
|
|
|
connection.login(xmppuser, password, "Essentials-XMPP");
|
|
connection.sendPacket(new Presence(Presence.Type.available, "No one online.", 2, Presence.Mode.available));
|
|
|
|
connection.getRoster().setSubscriptionMode(SubscriptionMode.accept_all);
|
|
chatManager = connection.getChatManager();
|
|
chatManager.addChatListener(this);
|
|
return true;
|
|
} catch (final XMPPException ex) {
|
|
logger.log(Level.WARNING, "Failed to connect to server: " + server, ex);
|
|
logger.log(Level.WARNING, "Connected: " + connection.isConnected());
|
|
logger.log(Level.WARNING, "Secure: " + connection.isSecureConnection());
|
|
logger.log(Level.WARNING, "Using TLS: " + connection.isUsingTLS());
|
|
logger.log(Level.WARNING, "Authenticated: " + connection.getSASLAuthentication().isAuthenticated());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
final 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));
|
|
}
|
|
}
|
|
|
|
final void updatePresence() {
|
|
if (connection == null) {
|
|
parent.getEss().getLogger().warning(AdventureUtil.miniToLegacy(tlLiteral("xmppNotConfigured")));
|
|
return;
|
|
}
|
|
|
|
final int usercount;
|
|
final StringBuilder stringBuilder = new StringBuilder();
|
|
|
|
usercount = parent.getEss().getOnlinePlayers().size();
|
|
|
|
if (usercount == 0) {
|
|
final String presenceMsg = "No one online.";
|
|
connection.sendPacket(new Presence(Presence.Type.available, presenceMsg, 2, Presence.Mode.dnd));
|
|
}
|
|
if (usercount == 1) {
|
|
final String presenceMsg = "1 player online.";
|
|
connection.sendPacket(new Presence(Presence.Type.available, presenceMsg, 2, Presence.Mode.available));
|
|
}
|
|
if (usercount > 1) {
|
|
stringBuilder.append(usercount).append(" players online.");
|
|
connection.sendPacket(new Presence(Presence.Type.available, stringBuilder.toString(), 2, Presence.Mode.available));
|
|
}
|
|
}
|
|
|
|
@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 final void reloadConfig() {
|
|
logger.removeHandler(this);
|
|
config.load();
|
|
synchronized (chats) {
|
|
disconnect();
|
|
chats.clear();
|
|
if (!connect()) {
|
|
return;
|
|
}
|
|
startLoggerThread();
|
|
}
|
|
if (config.getBoolean("log-enabled", false)) {
|
|
logger.addHandler(this);
|
|
logUsers = config.getList("log-users", String.class);
|
|
final String level = config.getString("log-level", "info");
|
|
try {
|
|
logLevel = Level.parse(level.toUpperCase(Locale.ENGLISH));
|
|
} catch (final 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 (final Exception ignored) {
|
|
// 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(() -> {
|
|
final Set<LogRecord> copy = new HashSet<>();
|
|
final Set<String> failedUsers = new HashSet<>();
|
|
while (threadrunning) {
|
|
synchronized (logrecords) {
|
|
if (!logrecords.isEmpty()) {
|
|
copy.addAll(logrecords);
|
|
logrecords.clear();
|
|
}
|
|
}
|
|
if (!copy.isEmpty()) {
|
|
for (final String user : logUsers) {
|
|
try {
|
|
XMPPManager.this.startChat(user);
|
|
for (final LogRecord logRecord : copy) {
|
|
final String message = formatter.format(logRecord);
|
|
if (!XMPPManager.this.sendMessage(user, FormatUtil.stripLogColorFormat(message))) {
|
|
failedUsers.add(user);
|
|
break;
|
|
}
|
|
|
|
}
|
|
} catch (final 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 (final 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<Player> matches = parent.getServer().matchPlayer(parts[0].substring(1));
|
|
|
|
if (matches.isEmpty()) {
|
|
try {
|
|
chat.sendMessage("User " + parts[0] + " not found");
|
|
} catch (final XMPPException ex) {
|
|
logger.log(Level.WARNING, "Failed to send xmpp message.", ex);
|
|
}
|
|
} else {
|
|
final String from = "[" + parent.getUserByAddress(StringUtils.parseBareAddress(chat.getParticipant())) + ">";
|
|
for (final Player p : matches) {
|
|
p.sendMessage(from + p.getDisplayName() + "] " + message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void sendCommand(final Chat chat, final String message) {
|
|
if (config.getList("op-users", String.class).contains(StringUtils.parseBareAddress(chat.getParticipant()))) {
|
|
parent.getServer().getScheduler().runTask(parent, () -> {
|
|
try {
|
|
parent.getServer().dispatchCommand(Console.getInstance().getCommandSender(), message.substring(1));
|
|
} catch (final 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);
|
|
}
|
|
}
|
|
|
|
public boolean isConfigValid() {
|
|
final String server = config.getString("xmpp.server", null);
|
|
return server != null && !server.equals("example.com");
|
|
}
|
|
}
|