TCPController.java

/**
 *Copyright [2008-2009] [dennis zhuang]
 *Licensed 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 com.google.code.hs4j.network.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

import com.google.code.hs4j.network.config.Configuration;
import com.google.code.hs4j.network.core.CodecFactory;
import com.google.code.hs4j.network.core.EventType;
import com.google.code.hs4j.network.core.Handler;
import com.google.code.hs4j.network.core.Session;
import com.google.code.hs4j.network.core.impl.StandardSocketOption;
import com.google.code.hs4j.network.nio.impl.SocketChannelController;

/**
 * Controller for tcp server
 * 
 * @author dennis
 */
public class TCPController extends SocketChannelController 
		 {

	private ServerSocketChannel serverSocketChannel;

	/**
	 * Accept backlog queue size
	 */
	private int backlog = 500; // default 500

	public int getBacklog() {
		return this.backlog;
	}

	public void setBacklog(int backlog) {
		if (isStarted()) {
			throw new IllegalStateException();
		}
		if (backlog < 0) {
			throw new IllegalArgumentException("backlog<0");
		}
		this.backlog = backlog;
	}

	public TCPController() {
		super();
	}

	public TCPController(Configuration configuration) {
		super(configuration, null, null);

	}

	public TCPController(Configuration configuration, CodecFactory codecFactory) {
		super(configuration, null, codecFactory);
	}

	public TCPController(Configuration configuration, Handler handler,
			CodecFactory codecFactory) {
		super(configuration, handler, codecFactory);
	}

	private int connectionTime, latency, bandwidth;

	public void setPerformancePreferences(int connectionTime, int latency,
			int bandwidth) {
		this.connectionTime = connectionTime;
		this.latency = latency;
		this.bandwidth = bandwidth;
	}

	@Override
	protected void doStart() throws IOException {
		this.serverSocketChannel = ServerSocketChannel.open();
		this.serverSocketChannel.socket().setSoTimeout(this.soTimeout);
		if (this.connectionTime != 0 || this.latency != 0
				|| this.bandwidth != 0) {
			this.serverSocketChannel.socket().setPerformancePreferences(
					this.connectionTime, this.latency, this.bandwidth);
		}
		this.serverSocketChannel.configureBlocking(false);

		if (this.socketOptions.get(StandardSocketOption.SO_REUSEADDR) != null) {
			this.serverSocketChannel.socket().setReuseAddress(
					StandardSocketOption.SO_REUSEADDR.type().cast(
							this.socketOptions
									.get(StandardSocketOption.SO_REUSEADDR)));
		}
		if (this.socketOptions.get(StandardSocketOption.SO_RCVBUF) != null) {
			this.serverSocketChannel.socket().setReceiveBufferSize(
					StandardSocketOption.SO_RCVBUF.type().cast(
							this.socketOptions
									.get(StandardSocketOption.SO_RCVBUF)));

		}
		if (this.localSocketAddress != null) {
			this.serverSocketChannel.socket().bind(this.localSocketAddress,
					this.backlog);
		} else {
			this.serverSocketChannel.socket().bind(
					new InetSocketAddress("localhost", 0), this.backlog);
		}
		setLocalSocketAddress((InetSocketAddress) this.serverSocketChannel
				.socket().getLocalSocketAddress());
		this.selectorManager.registerChannel(this.serverSocketChannel,
				SelectionKey.OP_ACCEPT, null);
	}

	@Override
	public void onAccept(SelectionKey selectionKey) throws IOException {
		// �������رգ�ȡ������
		if (!this.serverSocketChannel.isOpen()) {
			selectionKey.cancel();
			return;
		}
		SocketChannel sc = null;
		try {
			sc = this.serverSocketChannel.accept();
			if (sc != null) {
				configureSocketChannel(sc);
				Session session = buildSession(sc);
				// enable read
				this.selectorManager.registerSession(session,
						EventType.ENABLE_READ);
				session.start();
				super.onAccept(selectionKey); // for statistics
			} else {
				log.debug("Accept fail");
			}
		} catch (IOException e) {
			closeAcceptChannel(selectionKey, sc);
			log.error("Accept connection error", e);
			notifyException(e);
		}
	}

	/**
	 * 
	 * @param sk
	 * @param sc
	 * @throws IOException
	 * @throws SocketException
	 */
	private void closeAcceptChannel(SelectionKey sk, SocketChannel sc)
			throws IOException, SocketException {
		if (sk != null) {
			sk.cancel();
		}
		if (sc != null) {
			sc.socket().setSoLinger(true, 0); // await TIME_WAIT status
			sc.socket().shutdownOutput();
			sc.close();
		}
	}

	public void closeChannel(Selector selector) throws IOException {
		if (this.serverSocketChannel != null) {
			this.serverSocketChannel.close();
		}
	}

	public void unbind() throws IOException {
		stop();
	}

}