package jp.ameba.mongo;
import java.net.SocketAddress;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import jp.ameba.mongo.protocol.Consistency;
import jp.ameba.mongo.protocol.Delete;
import jp.ameba.mongo.protocol.GetMore;
import jp.ameba.mongo.protocol.Insert;
import jp.ameba.mongo.protocol.KillCursors;
import jp.ameba.mongo.protocol.Query;
import jp.ameba.mongo.protocol.Request;
import jp.ameba.mongo.protocol.RequestFuture;
import jp.ameba.mongo.protocol.Response;
import jp.ameba.mongo.protocol.Update;
import org.bson.BSONObject;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelFuture;
import org.jboss.netty.channel.ChannelFutureListener;
/**
* MongoDB との非同期通信を行うクライアント
*
* @author suguru
*/
public class MongoConnectionImpl implements MongoConnection {
// Netty用の ChannelFactory
private Channel channel;
// 初期接続先アドレス一覧
private SocketAddress serverAddress;
// 接続設定
private MongoConfiguration connectionConfig;
/**
* {@link MongoConnectionImpl} を構成します。
*/
public MongoConnectionImpl(
Channel channel,
SocketAddress serverAddress,
MongoConfiguration connectionConfig) {
this.channel = channel;
this.serverAddress = serverAddress;
this.connectionConfig = connectionConfig;
}
@Override
public int getChannelId() {
return channel.getId();
}
/**
* MongoDB へ接続します。
*/
public void open() {
MongoFuture future = openAsync();
try {
future.await(connectionConfig.getConnectTimeout(), TimeUnit.MILLISECONDS);
} catch (InterruptedException ex) {
}
if (!future.isSuccess()) {
throw new MongoException("No available MongoDB servers.");
}
}
/**
* 非同期処理で MongoDB へ接続します。
* @return
*/
public MongoFuture openAsync() {
MongoFuture mongoFuture = new MongoFuture();
ChannelFuture channelFuture = channel.connect(serverAddress);
channelFuture.addListener(new OpenChannelFutureListener(mongoFuture));
return mongoFuture;
}
/**
* MongoDB への接続を閉じます。
*/
public void close() {
MongoFuture future = closeAsync();
try {
future.await(connectionConfig.getOperationTimeout(), TimeUnit.MILLISECONDS);
} catch (InterruptedException ex) {
}
if (!future.isSuccess()) {
throw new MongoException("Failed to close connections");
}
}
/**
* 非同期処理で MongoDB への接続を閉じます。
* @return
*/
public MongoFuture closeAsync() {
MongoFuture mongoFuture = new MongoFuture();
CloseChannelFutureListener channelFutureListener = new CloseChannelFutureListener(mongoFuture);
ChannelFuture channelFuture = channel.close();
channelFuture.addListener(channelFutureListener);
return mongoFuture;
}
/**
* 接続完了処理のための非同期リスナ
*/
private class OpenChannelFutureListener implements ChannelFutureListener {
private MongoFuture mongoFuture;
public OpenChannelFutureListener(MongoFuture mongoFuture) {
this.mongoFuture = mongoFuture;
}
public synchronized void operationComplete(ChannelFuture channelFuture) throws Exception {
if (channelFuture.isSuccess()) {
// １つでも接続に成功していれば、成功とみなす
mongoFuture.setSuccess(true);
}
// 待ち受けスレッドへ通知
synchronized (mongoFuture) {
mongoFuture.notifyAll();
}
};
}
/**
* 切断処理のための非同期リスナ
* @author suguru
*/
private class CloseChannelFutureListener implements ChannelFutureListener {
private MongoFuture mongoFuture;
public CloseChannelFutureListener(MongoFuture mongoFuture) {
this.mongoFuture = mongoFuture;
}
@Override
public synchronized void operationComplete(ChannelFuture channelFuture) throws Exception {
synchronized (this) {
if (channelFuture.isSuccess()) {
mongoFuture.setSuccess(true);
}
// 待ち受けスレッドへ通知
synchronized (mongoFuture) {
mongoFuture.notifyAll();
}
}
}
}
/**
* 接続がオープンであるか確認します。
* @return
*/
public boolean isOpen() {
return channel.isOpen();
}
/**
* 接続中であるか確認します。
* @return
*/
public boolean isConnected() {
return channel.isConnected();
}
/**
* 更新を実行します。
* @param databaseName
* @param collectionName
* @param selector
* @param update
* @param upsert
* @param multiUpdate
* @param consistency
*/
public void update(Update update) {
sendUpdateRequest(update);
}
/**
* 新しいオブジェクトを新規に永続化します。
* @param insert
*/
public void insert(Insert insert) {
sendUpdateRequest(insert);
}
/**
* 指定のオブジェクトを削除します。
* @param delete
*/
public void delete(Delete delete) {
sendUpdateRequest(delete);
}
/**
* クエリを送信します。
* @param query
* @return
*/
public Response query(Query query) {
return sendQueryRequest(query);
}
/**
* カーソルの追加取得を送信します。
* @param getMore
* @return
*/
public Response getMore(GetMore getMore) {
return sendQueryRequest(getMore);
}
/**
* カーソルを取得します。
* @param query
* @return
*/
public MongoCursor cursor(String databaseName, String collectionName) {
return new MongoCursor(this, databaseName, collectionName);
}
/**
* カーソルクリアを送信します。
* @param kilLCursors
*/
public void killCursors(KillCursors killCursors) {
sendUpdateRequest(killCursors);
}
/**
* 更新系リクエストを送信します。
* {@link Consistency} の状況によって、サーバーからの
* 返却までの間、処理をブロックします。
*
* @param request
*/
private void sendUpdateRequest(Request request) {
channel.write(request);
Consistency consistency = request.getConsistency();
BSONObject getErrorQuery = consistency.getLastErrorQuery();
if (getErrorQuery != null) {
waitLastError(request);
}
}
/**
* クエリリクエストを送信し、レスポンスを取得するまでブロックします。
* @param request
* @return
*/
private Response sendQueryRequest(Request request) {
channel.write(request);
RequestFuture requestFuture = request.getFuture();
try {
Response response = requestFuture.get();
if (!response.isOk()) {
throw new MongoException("Query failure: " + response.getErrorMessage());
} else {
return response;
}
} catch (ExecutionException ex) {
throw new MongoException(ex);
} catch (InterruptedException ex) {
throw new MongoException(ex);
}
}
/**
* 指定のリクエストの getLastError の返りを待ちます。
*
* @param request
*/
private void waitLastError(Request request) {
// ResponseFuture を取得
RequestFuture requestFuture = request.getFuture();
if (requestFuture != null) {
try {
Response response = requestFuture.get();
BSONObject object = response.getDocuments().get(0);
// OK でない場合は、例外を発する
if (!response.isOk()) {
String error = (String) object.get("errmsg");
throw new MongoException(error);
}
String err = (String) object.get("err");
if (err != null) {
Integer code = (Integer) object.get("code");
throw new MongoException(err, code);
}
} catch (ExecutionException ex) {
throw new MongoException(ex);
} catch (InterruptedException ex) {
throw new MongoException(ex);
}
}
}
@Override
protected void finalize() throws Throwable {
closeAsync();
}
}