org.jboss.netty.channel.ChannelUpstreamHandler Java Examples

protected ChannelUpstreamHandler createCoreHandler() {
  // Supporting chunking is difficult because James offers a line-oriented interface.
  // By saving the Netty channel into James' SMTPSession, we can add a Netty handler
  // that can intercept the BDAT message body before James attempts to parse it
  // into a series of lines.
  return new BasicChannelUpstreamHandler(protocol, secure) {
    @Override
    protected ProtocolSession createSession(ChannelHandlerContext ctx) throws Exception {
      ProtocolSession session = super.createSession(ctx);
      session.setAttachment(NETTY_CHANNEL, ctx.getChannel(), State.Connection);
      return session;
    }
  };
}
 

@Override
protected ChannelPipelineFactory createPipelineFactory(ChannelGroup group) {

    return new AbstractSSLAwareChannelPipelineFactory(
        getTimeout(),
        maxCurConnections,
        maxCurConnectionsPerIP,
        group,
        secure != null ? secure.getEnabledCipherSuites() : null,
        eHandler,
        getFrameHandlerFactory(),
        hashedWheelTimer) {

        @Override
        protected ChannelUpstreamHandler createHandler() {
            return coreHandler;
        }

        @Override
        protected boolean isSSLSocket() {
            return getSSLContext() != null && secure != null && !secure.isStartTLS();
        }

        @Override
        protected SSLContext getSSLContext() {
            if (secure != null) {
                return secure.getContext();
            } else  {
                return null;
            }
        }
    };

}
 

@Override
protected ChannelPipelineFactory createPipelineFactory(ChannelGroup group) {
    return new AbstractExecutorAwareChannelPipelineFactory(getTimeout(), connectionLimit, connPerIP, group,
        enabledCipherSuites, getExecutionHandler(), getFrameHandlerFactory(), timer) {
        @Override
        protected SSLContext getSSLContext() {
            if (encryption == null) {
                return null;
            } else {
                return encryption.getContext();
            }
        }

        @Override
        protected boolean isSSLSocket() {
            return encryption != null && !encryption.isStartTLS();
        }


        @Override
        protected ChannelUpstreamHandler createHandler() {
            return AbstractConfigurableAsyncServer.this.createCoreHandler();

        }

        @Override
        protected ConnectionCountHandler getConnectionCountHandler() {
            return AbstractConfigurableAsyncServer.this.getConnectionCountHandler();
        }

    };
}
 

@Override
protected ChannelUpstreamHandler createCoreHandler() {
    return new ManageSieveChannelUpstreamHandler(manageSieveProcessor,
        getEncryption() == null ? null : getEncryption().getContext(),
        getEnabledCipherSuites(),
        isSSL(),
        LOGGER);
}
 

@Override
protected ChannelUpstreamHandler createCoreHandler() {
    ImapChannelUpstreamHandler coreHandler;
    Encryption secure = getEncryption();
    if (secure != null && secure.isStartTLS()) {
       coreHandler = new ImapChannelUpstreamHandler(hello, processor, encoder, compress, plainAuthDisallowed, secure.getContext(), getEnabledCipherSuites(), imapMetrics);
    } else {
       coreHandler = new ImapChannelUpstreamHandler(hello, processor, encoder, compress, plainAuthDisallowed, imapMetrics);
    }
    return coreHandler;
}
 

protected ChannelUpstreamHandler createCoreHandler() {
    return new BasicChannelUpstreamHandler(new ProtocolMDCContextFactory.Standard(), protocol, secure);
}
 

@Override
protected ChannelUpstreamHandler createCoreHandler() {
    return coreHandler; 
}
 

@Override
protected ChannelUpstreamHandler createCoreHandler() {
    SMTPProtocol protocol = new SMTPProtocol(getProtocolHandlerChain(), lmtpConfig);
    return new SMTPChannelUpstreamHandler(protocol, lmtpMetrics);
}
 

@Override
protected ChannelUpstreamHandler createCoreHandler() {
    return coreHandler;
}
 

public ProtoPipelineFactory(ChannelUpstreamHandler handlerFactory,
    MessageLite defaultInstance) {
  this.handler = handlerFactory;
  this.defaultInstance = defaultInstance;
}
 

/**
 * Create the core {@link ChannelUpstreamHandler} to use
 *
 * @return coreHandler
 */
protected abstract ChannelUpstreamHandler createHandler();
 

protected abstract ChannelUpstreamHandler createCoreHandler();