/** * Gets the server address. * * @return the server address */ public ServerAddress getServerAddress() { return connectionId.getServerId().getAddress(); }
private MongoTimeoutException createTimeoutException() { return new MongoTimeoutException(format("Timed out after %d ms while waiting for a connection to server %s.", settings.getMaxWaitTime(MILLISECONDS), serverId.getAddress())); }
ConnectionPoolStatistics(final ConnectionPoolOpenedEvent event) { serverAddress = event.getServerId().getAddress(); settings = event.getSettings(); }
/** * If there was a socket exception that wasn't some form of interrupted read, increment the generation count so that any connections * created prior will be discarded. * * @param connection the connection that generated the exception * @param t the exception */ private void incrementGenerationOnSocketException(final InternalConnection connection, final Throwable t) { if (t instanceof MongoSocketException && !(t instanceof MongoSocketReadTimeoutException)) { if (LOGGER.isWarnEnabled()) { LOGGER.warn(format("Got socket exception on connection [%s] to %s. All connections to %s will be closed.", getId(connection), serverId.getAddress(), serverId.getAddress())); } invalidate(); } }
private void logStateChange(final ServerDescription previousServerDescription, final ServerDescription currentServerDescription) { if (shouldLogStageChange(previousServerDescription, currentServerDescription)) { if (currentServerDescription.getException() != null) { LOGGER.info(format("Exception in monitor thread while connecting to server %s", serverId.getAddress()), currentServerDescription.getException()); } else { LOGGER.info(format("Monitor thread successfully connected to server with description %s", currentServerDescription)); } } }
@Override public void close() { // All but the first call is a no-op if (!isClosed.getAndSet(true)) { if (!DefaultConnectionPool.this.closed) { connectionPoolListener.connectionCheckedIn(new ConnectionCheckedInEvent(getId(wrapped))); if (LOGGER.isTraceEnabled()) { LOGGER.trace(format("Checked in connection [%s] to server %s", getId(wrapped), serverId.getAddress())); } } pool.release(wrapped, wrapped.isClosed() || shouldPrune(wrapped)); } }
String getMBeanObjectName(final ServerId serverId) { String name = format("org.mongodb.driver:type=ConnectionPool,clusterId=%s,host=%s,port=%s", ensureValidValue(serverId.getClusterId().getValue()), ensureValidValue(serverId.getAddress().getHost()), serverId.getAddress().getPort()); if (serverId.getClusterId().getDescription() != null) { name = format("%s,description=%s", name, ensureValidValue(serverId.getClusterId().getDescription())); } return name; }
@Override public void open() { isTrue("Open already called", stream == null); stream = streamFactory.create(serverId.getAddress()); try { stream.open(); description = connectionInitializer.initialize(this); opened.set(true); sendCompressor = findSendCompressor(description); LOGGER.info(format("Opened connection [%s] to %s", getId(), serverId.getAddress())); } catch (Throwable t) { close(); if (t instanceof MongoException) { throw (MongoException) t; } else { throw new MongoException(t.toString(), t); } } }
@Override public synchronized void run() { try { if (shouldPrune()) { if (LOGGER.isDebugEnabled()) { LOGGER.debug(format("Pruning pooled connections to %s", serverId.getAddress())); } pool.prune(); } if (shouldEnsureMinSize()) { if (LOGGER.isDebugEnabled()) { LOGGER.debug(format("Ensuring minimum pooled connections to %s", serverId.getAddress())); } pool.ensureMinSize(settings.getMinSize(), true); } } catch (MongoInterruptedException e) { // don't log interruptions due to the shutdownNow call on the ExecutorService } catch (Exception e) { LOGGER.warn("Exception thrown during connection pool background maintenance task", e); } } };
@Override public void close(final UsageTrackingInternalConnection connection) { if (!closed) { connectionPoolListener.connectionRemoved(new ConnectionRemovedEvent(getId(connection))); } if (LOGGER.isInfoEnabled()) { LOGGER.info(format("Closed connection [%s] to %s because %s.", getId(connection), serverId.getAddress(), getReasonForClosing(connection))); } connection.close(); }
DefaultServerMonitor(final ServerId serverId, final ServerSettings serverSettings, final ClusterClock clusterClock, final ChangeListener<ServerDescription> serverStateListener, final InternalConnectionFactory internalConnectionFactory, final ConnectionPool connectionPool) { this.serverSettings = notNull("serverSettings", serverSettings); this.serverId = notNull("serverId", serverId); this.serverMonitorListener = getServerMonitorListener(serverSettings); this.clusterClock = notNull("clusterClock", clusterClock); this.serverStateListener = serverStateListener; this.internalConnectionFactory = notNull("internalConnectionFactory", internalConnectionFactory); this.connectionPool = connectionPool; monitor = new ServerMonitorRunnable(); monitorThread = new Thread(monitor, "cluster-" + this.serverId.getClusterId() + "-" + this.serverId.getAddress()); monitorThread.setDaemon(true); isClosed = false; }
isTrue("Open already called", stream == null, callback); try { stream = streamFactory.create(serverId.getAddress()); } catch (Throwable t) { callback.onResult(null, t);
private ServerDescription getConnectingServerDescription(final Throwable exception) { return ServerDescription.builder().type(UNKNOWN).state(CONNECTING).address(serverId.getAddress()).exception(exception).build(); }
private ServerDescription lookupServerDescription(final InternalConnection connection) { if (LOGGER.isDebugEnabled()) { LOGGER.debug(format("Checking status of %s", serverId.getAddress())); } serverMonitorListener.serverHearbeatStarted(new ServerHeartbeatStartedEvent(connection.getDescription().getConnectionId())); long start = System.nanoTime(); try { BsonDocument isMasterResult = executeCommand("admin", new BsonDocument("ismaster", new BsonInt32(1)), clusterClock, connection); long elapsedTimeNanos = System.nanoTime() - start; averageRoundTripTime.addSample(elapsedTimeNanos); serverMonitorListener.serverHeartbeatSucceeded( new ServerHeartbeatSucceededEvent(connection.getDescription().getConnectionId(), isMasterResult, elapsedTimeNanos)); return createServerDescription(serverId.getAddress(), isMasterResult, connection.getDescription().getServerVersion(), averageRoundTripTime.getAverage()); } catch (RuntimeException e) { serverMonitorListener.serverHeartbeatFailed( new ServerHeartbeatFailedEvent(connection.getDescription().getConnectionId(), System.nanoTime() - start, e)); throw e; } }
private PooledConnection getPooledConnection(final long timeout, final TimeUnit timeUnit) { UsageTrackingInternalConnection internalConnection = pool.get(timeout, timeUnit); while (shouldPrune(internalConnection)) { pool.release(internalConnection, true); internalConnection = pool.get(timeout, timeUnit); } connectionPoolListener.connectionCheckedOut(new ConnectionCheckedOutEvent(internalConnection.getDescription().getConnectionId())); if (LOGGER.isTraceEnabled()) { LOGGER.trace(format("Checked out connection [%s] to server %s", getId(internalConnection), serverId.getAddress())); } return new PooledConnection(internalConnection); }
@Override public void invalidate() { if (!isClosed()) { serverStateListener.stateChanged(new ChangeEvent<ServerDescription>(description, ServerDescription.builder() .state(CONNECTING) .address(serverId.getAddress()) .build())); connectionPool.invalidate(); connect(); } }
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 void serverHeartbeatSucceeded(ServerHeartbeatSucceededEvent event) { synchronized (heartbeats) { ServerAddress address = event.getConnectionId().getServerId().getAddress(); Heartbeat beat = new Heartbeat(event); heartbeats.put(address, beat); members.addAll(beat.getHosts()); if (!members.isEmpty()) { updateLag(); } } }
String getMBeanObjectName(final ServerId serverId) { String name = format("org.mongodb.driver:type=ConnectionPool,clusterId=%s,host=%s,port=%s", ensureValidValue(serverId.getClusterId().getValue()), ensureValidValue(serverId.getAddress().getHost()), serverId.getAddress().getPort()); if (serverId.getClusterId().getDescription() != null) { name = format("%s,description=%s", name, ensureValidValue(serverId.getClusterId().getDescription())); } return name; }
@Override public void close(final UsageTrackingInternalConnection connection) { if (!closed) { connectionPoolListener.connectionRemoved(new ConnectionRemovedEvent(getId(connection))); } if (LOGGER.isInfoEnabled()) { LOGGER.info(format("Closed connection [%s] to %s because %s.", getId(connection), serverId.getAddress(), getReasonForClosing(connection))); } connection.close(); }