Beispiel #1
0
    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();
    }
Beispiel #2
0
    private boolean shutdown(long timeout, TimeUnit unit) throws InterruptedException {

      if (!isShutdown.compareAndSet(false, true)) return true;

      long start = System.nanoTime();
      boolean success = true;
      for (HostConnectionPool pool : pools.values())
        success &= pool.shutdown(timeout - Cluster.timeSince(start, unit), unit);
      return success;
    }
Beispiel #3
0
    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();
    }
Beispiel #4
0
    /*
     * When the set of live nodes change, the loadbalancer will change his
     * mind on host distances. It might change it on the node that came/left
     * but also on other nodes (for instance, if a node dies, another
     * previously ignored node may be now considered).
     *
     * This method ensures that all hosts for which a pool should exist
     * have one, and hosts that shouldn't don't.
     */
    private void updateCreatedPools() {
      for (Host h : cluster.getMetadata().allHosts()) {
        HostDistance dist = loadBalancingPolicy().distance(h);
        HostConnectionPool pool = pools.get(h);

        if (pool == null) {
          if (dist != HostDistance.IGNORED && h.getMonitor().isUp()) addOrRenewPool(h);
        } else if (dist != pool.hostDistance) {
          if (dist == HostDistance.IGNORED) {
            removePool(h);
          } else {
            pool.hostDistance = dist;
          }
        }
      }
    }
Beispiel #5
0
    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;
        }
      }
    }
Beispiel #6
0
 private void removePool(Host host) {
   HostConnectionPool pool = pools.remove(host);
   if (pool != null) pool.shutdown();
 }
Beispiel #7
0
 public void onRemove(Host host) {
   loadBalancer.onRemove(host);
   HostConnectionPool pool = pools.remove(host);
   if (pool != null) pool.shutdown();
 }
Beispiel #8
0
    private void shutdown() {

      if (!isShutdown.compareAndSet(false, true)) return;

      for (HostConnectionPool pool : pools.values()) 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);
    }
  }