Java ExecutorFilter.getExecutor方法代码示例

import org.apache.mina.filter.executor.ExecutorFilter; //导入方法依赖的package包/类
/**
 * Create a new thread pool monitor mbean, giving it the pool to attach to.
 *
 * @param acceptor
 *            The pool to attach to.
 */
public CoreThreadPool(final SocketAcceptor acceptor) {
    if (acceptor == null) {
        throw new NullPointerException("acceptor is null");
    }

    //ExecutorThreadModel threadModel = (ExecutorThreadModel) acceptor.getDefaultConfig().getThreadModel();
    //this.executor = (ThreadPoolExecutor) threadModel.getExecutor();

    final ExecutorFilter executorFilter = (ExecutorFilter) acceptor.getFilterChain().get(EXECUTOR_FILTER_NAME);
    this.executor = (ThreadPoolExecutor) executorFilter.getExecutor();
    this.mina = new MINAStatCollector(acceptor);
}
 

import org.apache.mina.filter.executor.ExecutorFilter; //导入方法依赖的package包/类
/**
 * Starts this acceptor by binding the socket acceptor. When the acceptor is already started, a warning will be
 * logged and the method invocation is otherwise ignored.
 */
@Override
public synchronized void start()
{
    if ( socketAcceptor != null )
    {
        Log.warn( "Unable to start acceptor (it is already started!)" );
        return;
    }

    try
    {
        // Configure the thread pool that is to be used.
        final int initialSize = ( configuration.getMaxThreadPoolSize() / 4 ) + 1;
        final ExecutorFilter executorFilter = new ExecutorFilter( initialSize, configuration.getMaxThreadPoolSize(), 60, TimeUnit.SECONDS );
        final ThreadPoolExecutor eventExecutor = (ThreadPoolExecutor) executorFilter.getExecutor();
        final ThreadFactory threadFactory = new NamedThreadFactory( name + "-thread-", eventExecutor.getThreadFactory(), true, null );
        eventExecutor.setThreadFactory( threadFactory );

        // Construct a new socket acceptor, and configure it.
        socketAcceptor = buildSocketAcceptor();

        if ( JMXManager.isEnabled() )
        {
            configureJMX( socketAcceptor, name );
        }

        final DefaultIoFilterChainBuilder filterChain = socketAcceptor.getFilterChain();
        filterChain.addFirst( ConnectionManagerImpl.EXECUTOR_FILTER_NAME, executorFilter );

        // Add the XMPP codec filter
        filterChain.addAfter( ConnectionManagerImpl.EXECUTOR_FILTER_NAME, ConnectionManagerImpl.XMPP_CODEC_FILTER_NAME, new ProtocolCodecFilter( new XMPPCodecFactory() ) );

        // Kill sessions whose outgoing queues keep growing and fail to send traffic
        filterChain.addAfter( ConnectionManagerImpl.XMPP_CODEC_FILTER_NAME, ConnectionManagerImpl.CAPACITY_FILTER_NAME, new StalledSessionsFilter() );

        // Ports can be configured to start connections in SSL (as opposed to upgrade a non-encrypted socket to an encrypted one, typically using StartTLS)
        if ( configuration.getTlsPolicy() == Connection.TLSPolicy.legacyMode )
        {
            final SslFilter sslFilter = encryptionArtifactFactory.createServerModeSslFilter();
            filterChain.addAfter( ConnectionManagerImpl.EXECUTOR_FILTER_NAME, ConnectionManagerImpl.TLS_FILTER_NAME, sslFilter );
        }

        // Throttle sessions who send data too fast
        if ( configuration.getMaxBufferSize() > 0 )
        {
            socketAcceptor.getSessionConfig().setMaxReadBufferSize( configuration.getMaxBufferSize() );
            Log.debug( "Throttling read buffer for connections to max={} bytes", configuration.getMaxBufferSize() );
        }

        // Start accepting connections
        socketAcceptor.setHandler( connectionHandler );
        socketAcceptor.bind( new InetSocketAddress( configuration.getBindAddress(), configuration.getPort() ) );
    }
    catch ( Exception e )
    {
        System.err.println( "Error starting " + configuration.getPort() + ": " + e.getMessage() );
        Log.error( "Error starting: " + configuration.getPort(), e );
        // Reset for future use.
        if (socketAcceptor != null) {
            try {
                socketAcceptor.unbind();
            } finally {
                socketAcceptor = null;
            }
        }
    }
}
 

import org.apache.mina.filter.executor.ExecutorFilter; //导入方法依赖的package包/类
@Override 
public void run()
{
    while ( !stop )
    {
        // wait polling time
        try
        {
            Thread.sleep( pollingInterval );
        }
        catch ( InterruptedException e )
        {
        }

        long tmpMsgWritten = 0l;
        long tmpMsgRead = 0l;
        long tmpBytesWritten = 0l;
        long tmpBytesRead = 0l;
        long tmpScheduledWrites = 0l;
        long tmpQueuevedEvents = 0l;

        for (IoSession session : polledSessions)
        {
            // upadating individual session statistics
            IoSessionStat sessStat = ( IoSessionStat ) session.getAttribute( KEY );

            long currentTimestamp = System.currentTimeMillis();
            // Calculate delta
            float pollDelta = (currentTimestamp - sessStat.lastPollingTime) / 1000f;
            // Store last polling time of this session
            sessStat.lastPollingTime = currentTimestamp;

            long readBytes = session.getReadBytes();
            long writtenBytes = session.getWrittenBytes();
            long readMessages = session.getReadMessages();
            long writtenMessages = session.getWrittenMessages();
            sessStat.byteReadThroughput = (readBytes - sessStat.lastByteRead) / pollDelta;
            sessStat.byteWrittenThroughput = (writtenBytes - sessStat.lastByteWrite) / pollDelta;
            sessStat.messageReadThroughput = (readMessages - sessStat.lastMessageRead) / pollDelta;
            sessStat.messageWrittenThroughput = (writtenMessages - sessStat.lastMessageWrite) / pollDelta;

            tmpMsgWritten += (writtenMessages - sessStat.lastMessageWrite);
            tmpMsgRead += (readMessages - sessStat.lastMessageRead);
            tmpBytesWritten += (writtenBytes - sessStat.lastByteWrite);
            tmpBytesRead += (readBytes - sessStat.lastByteRead);
            tmpScheduledWrites += session.getScheduledWriteMessages();

            ExecutorFilter executorFilter =
                    (ExecutorFilter) session.getFilterChain().get(EXECUTOR_FILTER_NAME);
            if (executorFilter != null) {
                Executor executor =  executorFilter.getExecutor();
                if (executor instanceof OrderedThreadPoolExecutor) {
                    tmpQueuevedEvents += ((OrderedThreadPoolExecutor) executor).getActiveCount();
                }
            }

            sessStat.lastByteRead = readBytes;
            sessStat.lastByteWrite = writtenBytes;
            sessStat.lastMessageRead = readMessages;
            sessStat.lastMessageWrite = writtenMessages;

        }

        totalMsgWritten.addAndGet(tmpMsgWritten);
        totalMsgRead.addAndGet(tmpMsgRead);
        totalBytesWritten.addAndGet(tmpBytesWritten);
        totalBytesRead.addAndGet(tmpBytesRead);
        totalScheduledWrites.set(tmpScheduledWrites);
        totalQueuedEvents.set(tmpQueuevedEvents);
    }
}
 

import org.apache.mina.filter.executor.ExecutorFilter; //导入方法依赖的package包/类
private void createClientSSLListeners() {
    // Start clients SSL unless it's been disabled.
    if (isClientSSLListenerEnabled()) {
        int port = getClientSSLListenerPort();
        String algorithm = JiveGlobals.getProperty("xmpp.socket.ssl.algorithm");
        if ("".equals(algorithm) || algorithm == null) {
            algorithm = "TLS";
        }
        try {
            // Create SocketAcceptor with correct number of processors
            sslSocketAcceptor = buildSocketAcceptor();
            // Customize Executor that will be used by processors to process incoming stanzas
            int eventThreads = JiveGlobals.getIntProperty("xmpp.client_ssl.processing.threads", 16);
            ExecutorFilter executorFilter = new ExecutorFilter();
            ThreadPoolExecutor eventExecutor = (ThreadPoolExecutor)executorFilter.getExecutor();
            final ThreadFactory originalThreadFactory = eventExecutor.getThreadFactory();
            ThreadFactory newThreadFactory = new ThreadFactory()
            {
                private final AtomicInteger threadId = new AtomicInteger( 0 );

                public Thread newThread( Runnable runnable )
                {
                    Thread t = originalThreadFactory.newThread( runnable );
                    t.setName("Old SSL executor thread - " + threadId.incrementAndGet() );
                    t.setDaemon( true );
                    return t;
                }
            };
            eventExecutor.setThreadFactory( newThreadFactory );
            eventExecutor.setCorePoolSize(eventThreads + 1);
            eventExecutor.setMaximumPoolSize(eventThreads + 1);
            eventExecutor.setKeepAliveTime(60, TimeUnit.SECONDS);

            sslSocketAcceptor.getDefaultConfig().setThreadModel(ThreadModel.MANUAL);
            // Add the XMPP codec filter
            sslSocketAcceptor.getFilterChain().addFirst("xmpp", new ProtocolCodecFilter(new XMPPCodecFactory()));
            sslSocketAcceptor.getFilterChain().addFirst("threadModel", executorFilter);
            // Kill sessions whose outgoing queues keep growing and fail to send traffic
            sslSocketAcceptor.getFilterChain().addAfter("xmpp", "outCap", new StalledSessionsFilter());

            // Add the SSL filter now since sockets are "borned" encrypted in the old ssl method
            SSLContext sslContext = SSLContext.getInstance(algorithm);
            KeyManagerFactory keyFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyFactory.init(SSLConfig.getKeyStore(), SSLConfig.getKeyPassword().toCharArray());
            TrustManagerFactory trustFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustFactory.init(SSLConfig.getc2sTrustStore());

            sslContext.init(keyFactory.getKeyManagers(),
                    trustFactory.getTrustManagers(),
                    new java.security.SecureRandom());

            SSLFilter sslFilter = new SSLFilter(sslContext);
            if (JiveGlobals.getProperty("xmpp.client.cert.policy","disabled").equals("needed")) {
                sslFilter.setNeedClientAuth(true);
            }
            else if(JiveGlobals.getProperty("xmpp.client.cert.policy","disabled").equals("wanted")) {
                sslFilter.setWantClientAuth(true);
            }
            sslSocketAcceptor.getFilterChain().addFirst("tls", sslFilter);

        }
        catch (Exception e) {
            System.err.println("Error starting SSL XMPP listener on port " + port + ": " +
                    e.getMessage());
            Log.error(LocaleUtils.getLocalizedString("admin.error.ssl"), e);
        }
    }
}
 

import org.apache.mina.filter.executor.ExecutorFilter; //导入方法依赖的package包/类
private void startClientSSLListeners(String localIPAddress) {
    if (!JiveGlobals.getBooleanProperty("xmpp.socket.ssl.active", true)) {
        // Do not start listener if service is disabled
        return;
    }
    // Start clients SSL unless it's been disabled.
    int port = JiveGlobals.getIntProperty("xmpp.socket.ssl.port", 5223);
    String algorithm = JiveGlobals.getXMLProperty("xmpp.socket.ssl.algorithm");
    if ("".equals(algorithm) || algorithm == null) {
        algorithm = "TLS";
    }
    // Create SocketAcceptor with correct number of processors
    sslSocketAcceptor = buildSocketAcceptor();
    // Customize thread model for c2s (old ssl port)
    int eventThreads = JiveGlobals.getIntProperty("xmpp.processor.threads.ssl", 16);
    ExecutorFilter executorFilter = new ExecutorFilter();
    ThreadPoolExecutor eventExecutor = (ThreadPoolExecutor)executorFilter.getExecutor();
    final ThreadFactory originalThreadFactory = eventExecutor.getThreadFactory();
    ThreadFactory newThreadFactory = new ThreadFactory()
    {
        private final AtomicInteger threadId = new AtomicInteger( 0 );

        public Thread newThread( Runnable runnable )
        {
            Thread t = originalThreadFactory.newThread( runnable );
            t.setName("Old SSL executor thread - " + threadId.incrementAndGet() );
            t.setDaemon( true );
            return t;
        }
    };
    eventExecutor.setThreadFactory( newThreadFactory );
    eventExecutor.setCorePoolSize(eventThreads + 1);
    eventExecutor.setMaximumPoolSize(eventThreads + 1);
    eventExecutor.setKeepAliveTime(60, TimeUnit.SECONDS);

    sslSocketAcceptor.getDefaultConfig().setThreadModel(ThreadModel.MANUAL);
    // Add the XMPP codec filter
    sslSocketAcceptor.getFilterChain().addFirst("xmpp", new ProtocolCodecFilter(new XMPPCodecFactory()));
    sslSocketAcceptor.getFilterChain().addFirst("threadModel", executorFilter);
                                                              
    try {
        // Add the SSL filter now since sockets are "borned" encrypted in the old ssl method
        SSLContext sslContext = SSLContext.getInstance(algorithm);
        KeyManagerFactory keyFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        keyFactory.init(SSLConfig.getKeyStore(), SSLConfig.getKeyPassword().toCharArray());
        TrustManagerFactory trustFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        trustFactory.init(SSLConfig.getTrustStore());

        sslContext.init(keyFactory.getKeyManagers(),
                trustFactory.getTrustManagers(),
                new java.security.SecureRandom());

        sslSocketAcceptor.getFilterChain().addFirst("tls", new SSLFilter(sslContext));

        // Listen on a specific network interface if it has been set.
        String interfaceName = JiveGlobals.getXMLProperty("xmpp.socket.network.interface");
        InetAddress bindInterface = null;
        if (interfaceName != null) {
            if (interfaceName.trim().length() > 0) {
                bindInterface = InetAddress.getByName(interfaceName);
            }
        }
        // Start accepting connections
        sslSocketAcceptor.bind(new InetSocketAddress(bindInterface, port), new ClientConnectionHandler());

        List<String> params = new ArrayList<String>();
        params.add(Integer.toString(port));
        Log.info(LocaleUtils.getLocalizedString("startup.ssl", params));
    }
    catch (Exception e) {
        System.err.println("Error starting SSL XMPP listener on port " + port + ": " +
                e.getMessage());
        Log.error(LocaleUtils.getLocalizedString("admin.error.ssl"), e);
    }
}
 

import org.apache.mina.filter.executor.ExecutorFilter; //导入方法依赖的package包/类
private void createClientSSLListeners() {
    // Start clients SSL unless it's been disabled.
    if (isClientSSLListenerEnabled()) {
        int port = getClientSSLListenerPort();
        String algorithm = JiveGlobals.getProperty("xmpp.socket.ssl.algorithm", "TLS");
        try {
            // Create SocketAcceptor with correct number of processors
            sslSocketAcceptor = buildSocketAcceptor("client_ssl");
            // Customize Executor that will be used by processors to process incoming stanzas
            int eventThreads = JiveGlobals.getIntProperty("xmpp.client_ssl.processing.threads", 16);
            ExecutorFilter executorFilter = new ExecutorFilter();
            ThreadPoolExecutor eventExecutor = (ThreadPoolExecutor)executorFilter.getExecutor();
            final ThreadFactory originalThreadFactory = eventExecutor.getThreadFactory();
            ThreadFactory newThreadFactory = new ThreadFactory()
            {
                private final AtomicInteger threadId = new AtomicInteger( 0 );

                public Thread newThread( Runnable runnable )
                {
                    Thread t = originalThreadFactory.newThread( runnable );
                    t.setName("Old SSL executor thread - " + threadId.incrementAndGet() );
                    t.setDaemon( true );
                    return t;
                }
            };
            eventExecutor.setThreadFactory( newThreadFactory );
            eventExecutor.setCorePoolSize(eventThreads + 1);
            eventExecutor.setMaximumPoolSize(eventThreads + 1);
            eventExecutor.setKeepAliveTime(60, TimeUnit.SECONDS);

            sslSocketAcceptor.getDefaultConfig().setThreadModel(ThreadModel.MANUAL);
            // Add the XMPP codec filter
            sslSocketAcceptor.getFilterChain().addFirst("xmpp", new ProtocolCodecFilter(new XMPPCodecFactory()));
            sslSocketAcceptor.getFilterChain().addFirst("threadModel", executorFilter);
            // Kill sessions whose outgoing queues keep growing and fail to send traffic
            sslSocketAcceptor.getFilterChain().addAfter("xmpp", "outCap", new StalledSessionsFilter());

            // Add the SSL filter now since sockets are "borned" encrypted in the old ssl method
            SSLContext sslContext = SSLContext.getInstance(algorithm);
            KeyManagerFactory keyFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyFactory.init(SSLConfig.getKeyStore(), SSLConfig.getKeyPassword().toCharArray());
            TrustManagerFactory trustFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustFactory.init(SSLConfig.getc2sTrustStore());

            sslContext.init(keyFactory.getKeyManagers(),
                    trustFactory.getTrustManagers(),
                    new java.security.SecureRandom());

            SSLFilter sslFilter = new SSLFilter(sslContext);
            if (JiveGlobals.getProperty("xmpp.client.cert.policy","disabled").equals("needed")) {
                sslFilter.setNeedClientAuth(true);
            }
            else if(JiveGlobals.getProperty("xmpp.client.cert.policy","disabled").equals("wanted")) {
                sslFilter.setWantClientAuth(true);
            }
            sslSocketAcceptor.getFilterChain().addFirst("tls", sslFilter);

        }
        catch (Exception e) {
            System.err.println("Error starting SSL XMPP listener on port " + port + ": " +
                    e.getMessage());
            Log.error(LocaleUtils.getLocalizedString("admin.error.ssl"), e);
        }
    }
}
 

import org.apache.mina.filter.executor.ExecutorFilter; //导入方法依赖的package包/类
private void createClientSSLListeners() {
    // Start clients SSL unless it's been disabled.
    if (isClientSSLListenerEnabled()) {
        int port = getClientSSLListenerPort();
        String algorithm = JiveGlobals.getProperty("xmpp.socket.ssl.algorithm", "TLS");
        try {
            // Create SocketAcceptor with correct number of processors
            sslSocketAcceptor = buildSocketAcceptor();
            // Customize Executor that will be used by processors to process incoming stanzas
            int eventThreads = JiveGlobals.getIntProperty("xmpp.client_ssl.processing.threads", 16);
            ExecutorFilter executorFilter = new ExecutorFilter();
            ThreadPoolExecutor eventExecutor = (ThreadPoolExecutor)executorFilter.getExecutor();
            final ThreadFactory originalThreadFactory = eventExecutor.getThreadFactory();
            ThreadFactory newThreadFactory = new ThreadFactory()
            {
                private final AtomicInteger threadId = new AtomicInteger( 0 );

                public Thread newThread( Runnable runnable )
                {
                    Thread t = originalThreadFactory.newThread( runnable );
                    t.setName("Old SSL executor thread - " + threadId.incrementAndGet() );
                    t.setDaemon( true );
                    return t;
                }
            };
            eventExecutor.setThreadFactory( newThreadFactory );
            eventExecutor.setCorePoolSize(eventThreads + 1);
            eventExecutor.setMaximumPoolSize(eventThreads + 1);
            eventExecutor.setKeepAliveTime(60, TimeUnit.SECONDS);

            sslSocketAcceptor.getDefaultConfig().setThreadModel(ThreadModel.MANUAL);
            // Add the XMPP codec filter
            sslSocketAcceptor.getFilterChain().addFirst("xmpp", new ProtocolCodecFilter(new XMPPCodecFactory()));
            sslSocketAcceptor.getFilterChain().addFirst("threadModel", executorFilter);
            // Kill sessions whose outgoing queues keep growing and fail to send traffic
            sslSocketAcceptor.getFilterChain().addAfter("xmpp", "outCap", new StalledSessionsFilter());

            // Add the SSL filter now since sockets are "borned" encrypted in the old ssl method
            SSLContext sslContext = SSLContext.getInstance(algorithm);
            KeyManagerFactory keyFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyFactory.init(SSLConfig.getKeyStore(), SSLConfig.getKeyPassword().toCharArray());
            TrustManagerFactory trustFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustFactory.init(SSLConfig.getc2sTrustStore());

            sslContext.init(keyFactory.getKeyManagers(),
                    trustFactory.getTrustManagers(),
                    new java.security.SecureRandom());

            SSLFilter sslFilter = new SSLFilter(sslContext);
            if (JiveGlobals.getProperty("xmpp.client.cert.policy","disabled").equals("needed")) {
                sslFilter.setNeedClientAuth(true);
            }
            else if(JiveGlobals.getProperty("xmpp.client.cert.policy","disabled").equals("wanted")) {
                sslFilter.setWantClientAuth(true);
            }
            sslSocketAcceptor.getFilterChain().addFirst("tls", sslFilter);

        }
        catch (Exception e) {
            System.err.println("Error starting SSL XMPP listener on port " + port + ": " +
                    e.getMessage());
            Log.error(LocaleUtils.getLocalizedString("admin.error.ssl"), e);
        }
    }
}