예제 #1
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;
    }
예제 #2
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;
          }
        }
      }
    }
예제 #3
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;
        }
      }
    }
예제 #4
0
  public static void main(String[] args) {

    for (int i = 0; i < args.length; ++i) {
      if ("-endpoint".equals(args[i])) {
        endpoint = args[++i];
      } else if ("-keyspace".equals(args[i])) {
        keyspace = args[++i];
      } else if ("-table".equals(args[i])) {
        table = args[++i];
      } else {
        System.err.println("ConsistencyTest -endpoint hostname -keyspace keyspace -table table");
      }
    }
    if (endpoint == null || keyspace == null || table == null) {
      System.err.println("ConsistencyTest -endpoint hostname -keyspace keyspace -table table");
      System.exit(1);
    }

    String[] endpoints = endpoint.split(":");

    try {
      cluster =
          Cluster.builder()
              .addContactPoints(endpoints)
              .withRetryPolicy(DefaultRetryPolicy.INSTANCE)
              .withLoadBalancingPolicy(new TokenAwarePolicy(new DCAwareRoundRobinPolicy()))
              .build();
      session = cluster.connect(keyspace);

      // work with ONE for both write and read
      long s1 = System.currentTimeMillis();
      Statement insert =
          QueryBuilder.insertInto(table)
              .value("user_id", 100)
              .value("fname", "john")
              .value("lname", "yamada")
              .value("number", 100);
      insert.setConsistencyLevel(ConsistencyLevel.ONE);
      session.execute(insert);
      long e1 = System.currentTimeMillis();
      System.out.println("write ONE time taken (ms) : " + (e1 - s1));

      long s2 = System.currentTimeMillis();
      Statement select =
          QueryBuilder.select().all().from(table).where(QueryBuilder.eq("user_id", 100));
      select.setConsistencyLevel(ConsistencyLevel.ONE);
      results = session.execute(select);
      for (Row row : results) {
        System.out.format(
            "%d %s %s %d\n",
            row.getInt("user_id"),
            row.getString("fname"),
            row.getString("lname"),
            row.getInt("number"));
      }
      long e2 = System.currentTimeMillis();
      System.out.println("read ONE time taken (ms) : " + (e2 - s2));

      Statement delete = QueryBuilder.delete().from(table).where(QueryBuilder.eq("user_id", 100));
      results = session.execute(delete);

      // work with QUORUM for both write and read
      long s3 = System.currentTimeMillis();
      Statement insert2 =
          QueryBuilder.insertInto(table)
              .value("user_id", 200)
              .value("fname", "john")
              .value("lname", "yamada")
              .value("number", 100);
      insert2.setConsistencyLevel(ConsistencyLevel.QUORUM);
      session.execute(insert2);
      long e3 = System.currentTimeMillis();
      System.out.println("write QUORUM time taken (ms) : " + (e3 - s3));

      long s4 = System.currentTimeMillis();
      Statement select2 =
          QueryBuilder.select().all().from(table).where(QueryBuilder.eq("user_id", 200));
      select2.setConsistencyLevel(ConsistencyLevel.QUORUM);
      results = session.execute(select2);
      for (Row row : results) {
        System.out.format(
            "%d %s %s %d\n",
            row.getInt("user_id"),
            row.getString("fname"),
            row.getString("lname"),
            row.getInt("number"));
      }
      long e4 = System.currentTimeMillis();
      System.out.println("read QUORUM time taken (ms) : " + (e4 - s4));

      Statement delete2 = QueryBuilder.delete().from(table).where(QueryBuilder.eq("user_id", 200));
      results = session.execute(delete2);

      // Clean up the connection by closing it
      cluster.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }