com.mongodb.internal.connection.DefaultServer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of mongo-java-driver Show documentation
Show all versions of mongo-java-driver Show documentation
The MongoDB Java Driver uber-artifact, containing the legacy driver, the mongodb-driver, mongodb-driver-core, and bson
/*
* Copyright 2008-present MongoDB, Inc.
*
* 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.mongodb.internal.connection;
import com.mongodb.MongoException;
import com.mongodb.MongoNodeIsRecoveringException;
import com.mongodb.MongoNotPrimaryException;
import com.mongodb.MongoSecurityException;
import com.mongodb.MongoSocketException;
import com.mongodb.MongoSocketReadTimeoutException;
import com.mongodb.async.SingleResultCallback;
import com.mongodb.connection.AsyncConnection;
import com.mongodb.connection.ClusterConnectionMode;
import com.mongodb.connection.Connection;
import com.mongodb.connection.ServerDescription;
import com.mongodb.connection.ServerId;
import com.mongodb.diagnostics.logging.Logger;
import com.mongodb.diagnostics.logging.Loggers;
import com.mongodb.event.CommandListener;
import com.mongodb.event.ServerClosedEvent;
import com.mongodb.event.ServerDescriptionChangedEvent;
import com.mongodb.event.ServerListener;
import com.mongodb.event.ServerOpeningEvent;
import com.mongodb.session.SessionContext;
import static com.mongodb.assertions.Assertions.isTrue;
import static com.mongodb.assertions.Assertions.notNull;
import static com.mongodb.connection.ServerConnectionState.CONNECTING;
import static com.mongodb.internal.async.ErrorHandlingResultCallback.errorHandlingCallback;
class DefaultServer implements ClusterableServer {
private static final Logger LOGGER = Loggers.getLogger("connection");
private final ServerId serverId;
private final ConnectionPool connectionPool;
private final ClusterConnectionMode clusterConnectionMode;
private final ConnectionFactory connectionFactory;
private final ServerMonitor serverMonitor;
private final ChangeListener serverStateListener;
private final ServerListener serverListener;
private final CommandListener commandListener;
private final ClusterClock clusterClock;
private volatile ServerDescription description;
private volatile boolean isClosed;
DefaultServer(final ServerId serverId, final ClusterConnectionMode clusterConnectionMode, final ConnectionPool connectionPool,
final ConnectionFactory connectionFactory, final ServerMonitorFactory serverMonitorFactory,
final ServerListener serverListener, final CommandListener commandListener, final ClusterClock clusterClock) {
this.serverListener = notNull("serverListener", serverListener);
this.commandListener = commandListener;
this.clusterClock = notNull("clusterClock", clusterClock);
notNull("serverAddress", serverId);
notNull("serverMonitorFactory", serverMonitorFactory);
this.clusterConnectionMode = notNull("clusterConnectionMode", clusterConnectionMode);
this.connectionFactory = notNull("connectionFactory", connectionFactory);
this.connectionPool = notNull("connectionPool", connectionPool);
this.serverStateListener = new DefaultServerStateListener();
this.serverId = serverId;
serverListener.serverOpening(new ServerOpeningEvent(this.serverId));
description = ServerDescription.builder().state(CONNECTING).address(serverId.getAddress()).build();
serverMonitor = serverMonitorFactory.create(serverStateListener);
serverMonitor.start();
}
@Override
public Connection getConnection() {
isTrue("open", !isClosed());
try {
return connectionFactory.create(connectionPool.get(), new DefaultServerProtocolExecutor(), clusterConnectionMode);
} catch (MongoSecurityException e) {
connectionPool.invalidate();
throw e;
} catch (MongoSocketException e) {
invalidate();
throw e;
}
}
@Override
public void getConnectionAsync(final SingleResultCallback callback) {
isTrue("open", !isClosed());
connectionPool.getAsync(new SingleResultCallback() {
@Override
public void onResult(final InternalConnection result, final Throwable t) {
if (t instanceof MongoSecurityException) {
connectionPool.invalidate();
} else if (t instanceof MongoSocketException) {
invalidate();
}
if (t != null) {
callback.onResult(null, t);
} else {
callback.onResult(connectionFactory.createAsync(result, new DefaultServerProtocolExecutor(), clusterConnectionMode),
null);
}
}
});
}
@Override
public ServerDescription getDescription() {
isTrue("open", !isClosed());
return description;
}
@Override
public void invalidate() {
isTrue("open", !isClosed());
serverStateListener.stateChanged(new ChangeEvent(description, ServerDescription.builder()
.state(CONNECTING)
.address(serverId.getAddress())
.build()));
connectionPool.invalidate();
connect();
}
@Override
public void close() {
if (!isClosed()) {
connectionPool.close();
serverMonitor.close();
isClosed = true;
serverListener.serverClosed(new ServerClosedEvent(serverId));
}
}
@Override
public boolean isClosed() {
return isClosed;
}
@Override
public void connect() {
serverMonitor.connect();
}
ConnectionPool getConnectionPool() {
return connectionPool;
}
private void handleThrowable(final Throwable t) {
if ((t instanceof MongoSocketException && !(t instanceof MongoSocketReadTimeoutException))
|| t instanceof MongoNotPrimaryException
|| t instanceof MongoNodeIsRecoveringException) {
invalidate();
}
}
private class DefaultServerProtocolExecutor implements ProtocolExecutor {
@Override
public T execute(final LegacyProtocol protocol, final InternalConnection connection) {
try {
protocol.setCommandListener(commandListener);
return protocol.execute(connection);
} catch (MongoException e) {
handleThrowable(e);
throw e;
}
}
@Override
public void executeAsync(final LegacyProtocol protocol, final InternalConnection connection,
final SingleResultCallback callback) {
protocol.setCommandListener(commandListener);
protocol.executeAsync(connection, errorHandlingCallback(new SingleResultCallback() {
@Override
public void onResult(final T result, final Throwable t) {
if (t != null) {
handleThrowable(t);
}
callback.onResult(result, t);
}
}, LOGGER));
}
@SuppressWarnings("unchecked")
@Override
public T execute(final CommandProtocol protocol, final InternalConnection connection,
final SessionContext sessionContext) {
try {
protocol.sessionContext(new ClusterClockAdvancingSessionContext(sessionContext, clusterClock));
return protocol.execute(connection);
} catch (MongoWriteConcernWithResponseException e) {
invalidate();
return (T) e.getResponse();
} catch (MongoException e) {
handleThrowable(e);
throw e;
}
}
@SuppressWarnings("unchecked")
@Override
public void executeAsync(final CommandProtocol protocol, final InternalConnection connection,
final SessionContext sessionContext, final SingleResultCallback callback) {
protocol.sessionContext(new ClusterClockAdvancingSessionContext(sessionContext, clusterClock));
protocol.executeAsync(connection, errorHandlingCallback(new SingleResultCallback() {
@Override
public void onResult(final T result, final Throwable t) {
if (t != null) {
if (t instanceof MongoWriteConcernWithResponseException) {
invalidate();
callback.onResult((T) ((MongoWriteConcernWithResponseException) t).getResponse(), null);
} else {
handleThrowable(t);
callback.onResult(null, t);
}
} else {
callback.onResult(result, null);
}
}
}, LOGGER));
}
}
private final class DefaultServerStateListener implements ChangeListener {
@Override
public void stateChanged(final ChangeEvent event) {
ServerDescription oldDescription = description;
description = event.getNewValue();
serverListener.serverDescriptionChanged(new ServerDescriptionChangedEvent(serverId, description, oldDescription));
}
}
}