path: root/juick-xmpp/src/main/java/com/juick/components/XMPPServer.java

package com.juick.components;

import com.juick.components.s2s.*;
import com.juick.service.*;
import com.juick.xmpp.JID;
import com.juick.xmpp.Stanza;
import com.juick.xmpp.StanzaChild;
import com.juick.xmpp.extensions.JuickMessage;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.env.Environment;
import org.xmlpull.v1.XmlPullParserException;

import javax.inject.Inject;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.util.*;
import java.util.concurrent.ExecutorService;

/**
 * @author ugnich
 */
public class XMPPServer implements AutoCloseable {
    private static final Logger logger = LoggerFactory.getLogger(XMPPServer.class);

    public ExecutorService service;
    private ConnectionRouter router;

    public String HOSTNAME, componentName;
    public String keystore;
    public String keystorePassword;
    public List<String> brokenSSLhosts;
    public List<String> bannedHosts;

    private final List<ConnectionIn> inConnections = Collections.synchronizedList(new ArrayList<>());
    private final List<ConnectionOut> outConnections = Collections.synchronizedList(new ArrayList<>());
    private final List<CacheEntry> outCache = Collections.synchronizedList(new ArrayList<>());
    private final List<StanzaListener> stanzaListeners = Collections.synchronizedList(new ArrayList<>());

    final public HashMap<String, StanzaChild> childParsers = new HashMap<>();

    @Inject
    public MessagesService messagesService;
    @Inject
    public UserService userService;
    @Inject
    public TagService tagService;
    @Inject
    public PMQueriesService pmQueriesService;
    @Inject
    public SubscriptionService subscriptionService;

    private JID jid;

    public XMPPServer(Environment env, ExecutorService service) {
        this.service = service;

        logger.info("component initialized");
        try {
            HOSTNAME = env.getProperty("hostname");
            componentName = env.getProperty("componentname");
            int componentPort = NumberUtils.toInt(env.getProperty("component_port"), 5347);
            int s2sPort = NumberUtils.toInt(env.getProperty("s2s_port"), 5269);
            keystore = env.getProperty("keystore");
            keystorePassword = env.getProperty("keystore_password");
            brokenSSLhosts = Arrays.asList(env.getProperty("broken_ssl_hosts", "").split(","));
            bannedHosts = Arrays.asList(env.getProperty("banned_hosts", "").split(","));
            jid = new JID(env.getProperty("xmppbot_jid"));
            boolean disabled = BooleanUtils.toBoolean(env.getProperty("xmpp_disabled", "false"));

            childParsers.put(JuickMessage.XMLNS, new JuickMessage());

            if (!disabled) {
                router = new ConnectionRouter(this, componentName, componentPort, env.getProperty("xmpp_password"));
                service.submit(router);

                service.submit(() -> {
                    final ServerSocket listener = new ServerSocket(s2sPort);
                    logger.info("s2s listener ready");
                    while (true) {
                        try {
                            Socket socket = listener.accept();
                            ConnectionIn client = new ConnectionIn(this, socket);
                            addConnectionIn(client);
                            service.submit(client);
                        } catch (Exception e) {
                            logger.error("s2s error", e);
                        }
                    }
                });
            }

        } catch (Exception e) {
            logger.error("XMPPComponent error", e);
        }
    }

    @Override
    public void close() throws Exception {
        synchronized (getOutConnections()) {
            for (Iterator<ConnectionOut> i = getOutConnections().iterator(); i.hasNext(); ) {
                ConnectionOut c = i.next();
                c.closeConnection();
                i.remove();
            }
        }

        synchronized (getInConnections()) {
            for (Iterator<ConnectionIn> i = getInConnections().iterator(); i.hasNext(); ) {
                ConnectionIn c = i.next();
                c.closeConnection();
                i.remove();
            }
        }
        logger.info("Xmpp server destroyed");
    }

    public void addConnectionIn(ConnectionIn c) {
        synchronized (getInConnections()) {
            getInConnections().add(c);
        }
    }

    public void addConnectionOut(ConnectionOut c) {
        synchronized (getOutConnections()) {
            getOutConnections().add(c);
        }
    }

    public void removeConnectionIn(ConnectionIn c) {
        synchronized (getInConnections()) {
            getInConnections().remove(c);
        }
    }

    public void removeConnectionOut(ConnectionOut c) {
        synchronized (getOutConnections()) {
            getOutConnections().remove(c);
        }
    }

    public String getFromCache(String hostname) {
        CacheEntry ret = null;
        synchronized (getOutCache()) {
            for (Iterator<CacheEntry> i = getOutCache().iterator(); i.hasNext(); ) {
                CacheEntry c = i.next();
                if (c.hostname != null && c.hostname.equals(hostname)) {
                    ret = c;
                    i.remove();
                    break;
                }
            }
        }
        return (ret != null) ? ret.xml : null;
    }

    public ConnectionOut getConnectionOut(String hostname, boolean needReady) {
        synchronized (getOutConnections()) {
            for (ConnectionOut c : getOutConnections()) {
                if (c.to != null && c.to.equals(hostname) && (!needReady || c.streamReady)) {
                    return c;
                }
            }
        }
        return null;
    }

    public ConnectionIn getConnectionIn(String streamID) {
        synchronized (getInConnections()) {
            for (ConnectionIn c : getInConnections()) {
                if (c.streamID != null && c.streamID.equals(streamID)) {
                    return c;
                }
            }
        }
        return null;
    }

    public void sendOut(Stanza s) {
        sendOut(s.to.Host, s.toString());
    }

    public void sendOut(String hostname, String xml) {
        boolean haveAnyConn = false;

        ConnectionOut connOut = null;
        synchronized (getOutConnections()) {
            for (ConnectionOut c : getOutConnections()) {
                if (c.to != null && c.to.equals(hostname)) {
                    if (c.streamReady) {
                        connOut = c;
                        break;
                    } else {
                        haveAnyConn = true;
                        break;
                    }
                }
            }
        }
        if (connOut != null) {
            connOut.sendStanza(xml);
            return;
        }

        boolean haveCache = false;
        synchronized (getOutCache()) {
            for (CacheEntry c : getOutCache()) {
                if (c.hostname != null && c.hostname.equals(hostname)) {
                    c.xml += xml;
                    c.tsUpdated = System.currentTimeMillis();
                    haveCache = true;
                    break;
                }
            }
            if (!haveCache) {
                getOutCache().add(new CacheEntry(hostname, xml));
            }
        }

        if (!haveAnyConn) {
            try {
                ConnectionOut connectionOut = new ConnectionOut(this, hostname);
                service.submit(connectionOut);
            } catch (CertificateException | UnrecoverableKeyException | NoSuchAlgorithmException | XmlPullParserException | KeyStoreException | KeyManagementException | IOException e) {
                logger.error("s2s out error", e);
            }
        }
    }

    public ConnectionRouter getRouter() {
        return router;
    }

    public List<ConnectionIn> getInConnections() {
        return inConnections;
    }

    public List<ConnectionOut> getOutConnections() {
        return outConnections;
    }

    public List<CacheEntry> getOutCache() {
        return outCache;
    }

    public void startDialback(String from, String streamId, String dbKey) throws Exception {
        ConnectionOut c = getConnectionOut(from, false);
        if (c != null) {
            c.sendDialbackVerify(streamId, dbKey);
        } else {
            c = new ConnectionOut(this, from, streamId, dbKey);
            service.submit(c);
        }
    }

    public List<StanzaListener> getStanzaListeners() {
        return stanzaListeners;
    }

    public void addStanzaListener(StanzaListener listener) {
        synchronized (stanzaListeners) {
            stanzaListeners.add(listener);
        }
    }

    public void onStanzaReceived(String type, Stanza xmlValue) {
        stanzaListeners.forEach(l -> l.stanzaReceived(type, xmlValue));
    }

    public JID getJid() {
        return jid;
    }
}