/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
package org.apache.mina.transport.socket.nio;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.SocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.Executor;
import org.apache.mina.core.polling.AbstractPollingIoAcceptor;
import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.service.IoProcessor;
import org.apache.mina.core.service.SimpleIoProcessorPool;
import org.apache.mina.core.service.TransportMetadata;
import org.apache.mina.transport.socket.DefaultSocketSessionConfig;
import org.apache.mina.transport.socket.SocketAcceptor;
import org.apache.mina.transport.socket.SocketSessionConfig;
/**
* {@link IoAcceptor} for socket transport (TCP/IP). This class
* handles incoming TCP/IP based socket connections.
*
* @author <a href="http://mina.apache.org">Apache MINA Project</a>
*/
public final class NioSocketAcceptor
extends AbstractPollingIoAcceptor<NioSession, ServerSocketChannel>
implements SocketAcceptor {
/**
* Define the number of socket that can wait to be accepted. Default
* to 50 (as in the SocketServer default).
*/
private int backlog = 50;
private boolean reuseAddress = false;
private volatile Selector selector;
/**
* Constructor for {@link NioSocketAcceptor} using default parameters (multiple thread model).
*/
public NioSocketAcceptor() {
super(new DefaultSocketSessionConfig(), NioProcessor.class);
((DefaultSocketSessionConfig) getSessionConfig()).init(this);
}
/**
* Constructor for {@link NioSocketAcceptor} using default parameters, and
* given number of {@link NioProcessor} for multithreading I/O operations.
*
* @param processorCount the number of processor to create and place in a
* {@link SimpleIoProcessorPool}
*/
public NioSocketAcceptor(int processorCount) {
super(new DefaultSocketSessionConfig(), NioProcessor.class, processorCount);
((DefaultSocketSessionConfig) getSessionConfig()).init(this);
}
/**
* Constructor for {@link NioSocketAcceptor} with default configuration but a
* specific {@link IoProcessor}, useful for sharing the same processor over multiple
* {@link IoService} of the same type.
* @param processor the processor to use for managing I/O events
*/
public NioSocketAcceptor(IoProcessor<NioSession> processor) {
super(new DefaultSocketSessionConfig(), processor);
((DefaultSocketSessionConfig) getSessionConfig()).init(this);
}
/**
* Constructor for {@link NioSocketAcceptor} with a given {@link Executor} for handling
* connection events and a given {@link IoProcessor} for handling I/O events, useful for
* sharing the same processor and executor over multiple {@link IoService} of the same type.
* @param executor the executor for connection
* @param processor the processor for I/O operations
*/
public NioSocketAcceptor(Executor executor, IoProcessor<NioSession> processor) {
super(new DefaultSocketSessionConfig(), executor, processor);
((DefaultSocketSessionConfig) getSessionConfig()).init(this);
}
/**
* {@inheritDoc}
*/
@Override
protected void init() throws Exception {
selector = Selector.open();
}
/**
* {@inheritDoc}
*/
@Override
protected void destroy() throws Exception {
if (selector != null) {
selector.close();
}
}
/**
* {@inheritDoc}
*/
public TransportMetadata getTransportMetadata() {
return NioSocketSession.METADATA;
}
/**
* {@inheritDoc}
*/
@Override
public SocketSessionConfig getSessionConfig() {
return (SocketSessionConfig) super.getSessionConfig();
}
/**
* {@inheritDoc}
*/
@Override
public InetSocketAddress getLocalAddress() {
return (InetSocketAddress) super.getLocalAddress();
}
/**
* {@inheritDoc}
*/
@Override
public InetSocketAddress getDefaultLocalAddress() {
return (InetSocketAddress) super.getDefaultLocalAddress();
}
/**
* {@inheritDoc}
*/
public void setDefaultLocalAddress(InetSocketAddress localAddress) {
setDefaultLocalAddress((SocketAddress) localAddress);
}
/**
* {@inheritDoc}
*/
public boolean isReuseAddress() {
return reuseAddress;
}
/**
* {@inheritDoc}
*/
public void setReuseAddress(boolean reuseAddress) {
synchronized (bindLock) {
if (isActive()) {
throw new IllegalStateException(
"reuseAddress can't be set while the acceptor is bound.");
}
this.reuseAddress = reuseAddress;
}
}
/**
* {@inheritDoc}
*/
public int getBacklog() {
return backlog;
}
/**
* {@inheritDoc}
*/
public void setBacklog(int backlog) {
synchronized (bindLock) {
if (isActive()) {
throw new IllegalStateException(
"backlog can't be set while the acceptor is bound.");
}
this.backlog = backlog;
}
}
/**
* {@inheritDoc}
*/
@Override
protected NioSession accept(IoProcessor<NioSession> processor,
ServerSocketChannel handle) throws Exception {
SelectionKey key = handle.keyFor(selector);
if ((key == null) || (!key.isValid()) || (!key.isAcceptable()) ) {
return null;
}
// accept the connection from the client
SocketChannel ch = handle.accept();
if (ch == null) {
return null;
}
return new NioSocketSession(this, processor, ch);
}
/**
* {@inheritDoc}
*/
@Override
protected ServerSocketChannel open(SocketAddress localAddress)
throws Exception {
// Creates the listening ServerSocket
ServerSocketChannel channel = ServerSocketChannel.open();
boolean success = false;
try {
// This is a non blocking socket channel
channel.configureBlocking(false);
// Configure the server socket,
ServerSocket socket = channel.socket();
// Set the reuseAddress flag accordingly with the setting
socket.setReuseAddress(isReuseAddress());
// and bind.
socket.bind(localAddress, getBacklog());
// Register the channel within the selector for ACCEPT event
channel.register(selector, SelectionKey.OP_ACCEPT);
success = true;
} finally {
if (!success) {
close(channel);
}
}
return channel;
}
/**
* {@inheritDoc}
*/
@Override
protected SocketAddress localAddress(ServerSocketChannel handle)
throws Exception {
return handle.socket().getLocalSocketAddress();
}
/**
* Check if we have at least one key whose corresponding channels is
* ready for I/O operations.
*
* This method performs a blocking selection operation.
* It returns only after at least one channel is selected,
* this selector's wakeup method is invoked, or the current thread
* is interrupted, whichever comes first.
*
* @return The number of keys having their ready-operation set updated
* @throws IOException If an I/O error occurs
* @throws ClosedSelectorException If this selector is closed
*/
@Override
protected int select() throws Exception {
return selector.select();
}
/**
* {@inheritDoc}
*/
@Override
protected Iterator<ServerSocketChannel> selectedHandles() {
return new ServerSocketChannelIterator(selector.selectedKeys());
}
/**
* {@inheritDoc}
*/
@Override
protected void close(ServerSocketChannel handle) throws Exception {
SelectionKey key = handle.keyFor(selector);
if (key != null) {
key.cancel();
}
handle.close();
}
/**
* {@inheritDoc}
*/
@Override
protected void wakeup() {
selector.wakeup();
}
/**
* Defines an iterator for the selected-key Set returned by the
* selector.selectedKeys(). It replaces the SelectionKey operator.
*/
private static class ServerSocketChannelIterator implements Iterator<ServerSocketChannel> {
/** The selected-key iterator */
private final Iterator<SelectionKey> iterator;
/**
* Build a SocketChannel iterator which will return a SocketChannel instead of
* a SelectionKey.
*
* @param selectedKeys The selector selected-key set
*/
private ServerSocketChannelIterator(Collection<SelectionKey> selectedKeys) {
iterator = selectedKeys.iterator();
}
/**
* Tells if there are more SockectChannel left in the iterator
* @return <code>true</code> if there is at least one more
* SockectChannel object to read
*/
public boolean hasNext() {
return iterator.hasNext();
}
/**
* Get the next SocketChannel in the operator we have built from
* the selected-key et for this selector.
*
* @return The next SocketChannel in the iterator
*/
public ServerSocketChannel next() {
SelectionKey key = iterator.next();
if ( key.isValid() && key.isAcceptable() ) {
return (ServerSocketChannel) key.channel();
}
return null;
}
/**
* Remove the current SocketChannel from the iterator
*/
public void remove() {
iterator.remove();
}
}
}