public void onUp(Host host) { HostConnectionPool previous = addHost(host); ; loadBalancer.onUp(host); // This should not be necessary but it's harmless if (previous != null) previous.shutdown(); }
public void onAdd(Host host) { HostConnectionPool previous = addHost(host); ; loadBalancer.onAdd(host); // This should not be necessary, especially since the host is // supposed to be new, but it's safer to make that work correctly // if the even is triggered multiple times. if (previous != null) previous.shutdown(); }
public void onDown(Host host) { loadBalancer.onDown(host); HostConnectionPool pool = pools.remove(host); // This should not be necessary but it's harmless if (pool != null) pool.shutdown(); // If we've remove a host, the loadBalancer is allowed to change his mind on host distances. for (Host h : cluster.getMetadata().allHosts()) { if (!h.getMonitor().isUp()) continue; HostDistance dist = loadBalancer.distance(h); if (dist != HostDistance.IGNORED) { HostConnectionPool p = pools.get(h); if (p == null) addHost(host); else p.hostDistance = dist; } } }
private HostConnectionPool addHost(Host host) { try { HostDistance distance = loadBalancer.distance(host); if (distance == HostDistance.IGNORED) { return pools.get(host); } else { logger.debug("Adding {} to list of queried hosts", host); return pools.put(host, new HostConnectionPool(host, distance, this)); } } catch (AuthenticationException e) { logger.error("Error creating pool to {} ({})", host, e.getMessage()); host.getMonitor() .signalConnectionFailure(new ConnectionException(e.getHost(), e.getMessage())); return pools.get(host); } catch (ConnectionException e) { logger.debug("Error creating pool to {} ({})", host, e.getMessage()); host.getMonitor().signalConnectionFailure(e); return pools.get(host); } }
public void onRemove(Host host) { loadBalancer.onRemove(host); HostConnectionPool pool = pools.remove(host); if (pool != null) pool.shutdown(); }
public void logState() { Session s = sessions[0]; Cluster cluster = s.getCluster(); LoadBalancingPolicy lbPolicy = cluster.getConfiguration().getPolicies().getLoadBalancingPolicy(); int count = 0; String keyspace = null; for (final Session session : sessions) { SessionManager sessionM = (SessionManager) session; Session.State sessionState = session.getState(); String newKeyspace = session.getLoggedKeyspace(); if (keyspace == null || !keyspace.equals(newKeyspace)) { count = 0; keyspace = newKeyspace; } int sessionKey = count++; logger.info("Host States for Session {}#{}:", keyspace, sessionKey); Collection<Host> hosts = sessionState.getConnectedHosts(); for (final Host host : hosts) { HostConnectionPool pool = sessionM.pools.get(host); HostDistance distance = lbPolicy.distance(host); // Whether or not the host will reconnect while in a suspected state. boolean isReconnectingFromSuspected = host.getInitialReconnectionAttemptFuture() != null && !host.getInitialReconnectionAttemptFuture().isDone(); // Whether or not the host will reconnect while in a down state. boolean isReconnectingFromDown = host.getReconnectionAttemptFuture() != null && !host.getReconnectionAttemptFuture().isDone(); if (pool != null) { String msg = String.format( "\t[%s:%s:%s] version=%s, state=%s, dist=%s, inFlight=%d, openConnections=%d, " + "trashedConnections=%d, reconnectFromSuspected=%s, reconnectFromDown=%s. pool=%s, poolClosed=%s", host.getDatacenter(), host.getRack(), host.getAddress(), host.getCassandraVersion(), host.state, distance, sessionState.getInFlightQueries(host), sessionState.getOpenConnections(host), pool.trash.size(), isReconnectingFromSuspected, isReconnectingFromDown, pool.hashCode(), pool.isClosed()); logger.info(msg); for (Connection connection : pool.connections) { long now = System.currentTimeMillis(); Connection.State state = connection.state.get(); if (connection.isClosed() || connection.isDefunct() || state == Connection.State.TRASHED || state == Connection.State.GONE || connection.maxIdleTime > 0 && connection.maxIdleTime < now) { logger.warn( "\t\t{} defunct?={}, state={}, maxIdleTime={}", connection, connection.isDefunct(), state, new Date(connection.maxIdleTime)); } else { logger.info( "\t\t{} defunct?={}, state={}, maxIdleTime={}", connection, connection.isDefunct(), state, new Date(connection.maxIdleTime)); } } for (Connection connection : pool.trash) { Connection.State state = connection.state.get(); if (connection.isClosed() || connection.isDefunct() || state == Connection.State.OPEN || state == Connection.State.GONE) { logger.warn( "\t\t{} defunct?={}, state={}, maxIdleTime={} [trash]", connection, connection.isDefunct(), state, new Date(connection.maxIdleTime)); } else { logger.info( "\t\t{} defunct?={}, state={}, maxIdleTime={} [trash]", connection, connection.isDefunct(), state, new Date(connection.maxIdleTime)); } } } else { logger.error("Pool is null for {}.", host); } // Register by host / session metrics if not already registered. // Replace periods with underscores (better graphite metric names) in host, also remove // backslashes. // If the host is no longer part of the session, it will return 0. String prefix = "Session." + sessionKey + "." + host.getAddress().toString().replaceAll("\\.", "_").replaceAll("/", "") + "."; String inFlightKey = prefix + "inFlight"; String openConnectionsKey = prefix + "openConnections"; if (!metricRegistry.getMetrics().containsKey(inFlightKey)) { metricRegistry.register( inFlightKey, new CachedGauge<Integer>(1, TimeUnit.SECONDS) { @Override protected Integer loadValue() { Session.State sessionState = session.getState(); if (sessionState.getConnectedHosts().contains(host)) { return sessionState.getInFlightQueries(host); } else { return 0; } } }); } if (!metricRegistry.getMetrics().containsKey(openConnectionsKey)) { metricRegistry.register( openConnectionsKey, new CachedGauge<Integer>(1, TimeUnit.SECONDS) { @Override protected Integer loadValue() { Session.State sessionState = session.getState(); if (sessionState.getConnectedHosts().contains(host)) { return sessionState.getOpenConnections(host); } else { return 0; } } }); } } } ControlConnection connection = cluster.manager.controlConnection; if (connection.isOpen()) { logger.info("Control connection is open to {}.", connection.connectedHost()); } else { logger.warn("Control connection is closed."); } List<Host> queryPlan = Lists.newArrayList(lbPolicy.newQueryPlan(null, new SimpleStatement(""))); if (queryPlan.size() == 0) { logger.warn("Query Plan is empty!"); } else { logger.info("Query Plan: {}", queryPlan); } }