public List<InetAddress> getEndpoints(TokenRange range) {
   Set<Host> hostSet = rangeMap.get(range);
   List<InetAddress> addresses = new ArrayList<>(hostSet.size());
   for (Host host : hostSet) {
     addresses.add(host.getAddress());
   }
   return addresses;
 }
 /** Common initializer. */
 private void init() {
   Metadata metadata = cluster.getMetadata();
   LOGGER.info("Connected to cluster: {}", metadata.getClusterName());
   for (Host h : metadata.getAllHosts()) {
     LOGGER.info(
         "Data center: {}; Hosts: {}; Rack: {}", h.getDatacenter(), h.getAddress(), h.getRack());
   }
 }
 private int getNumberOfUpNodes() {
   int count = 0;
   for (Host host : session.getCluster().getMetadata().getAllHosts()) {
     if (host.isUp()) {
       ++count;
     }
   }
   return count;
 }
 public void connect(String node) {
   cluster = Cluster.builder().addContactPoint(node).build();
   Metadata metadata = cluster.getMetadata();
   System.out.printf("Connected to cluster: %s\n", metadata.getClusterName());
   for (Host host : metadata.getAllHosts()) {
     System.out.printf(
         "Datatacenter: %s; Host: %s; Rack: %s\n",
         host.getDatacenter(), host.getAddress(), host.getRack());
   }
   session = cluster.connect("whoami");
 }
  @Override
  public void start() {
    cluster = Cluster.builder().addContactPoint(address).build();
    Metadata metadata = cluster.getMetadata();
    LOGGER.debug("Connected to cluster: {0}", metadata.getClusterName());
    for (Host host : metadata.getAllHosts()) {
      LOGGER.debug(
          "Datacenter: {0}; Host: {1}; Rack: {2}",
          host.getDatacenter(), host.getAddress(), host.getRack());
    }

    session = cluster.connect();
    try {
      session.execute(
          "CREATE KEYSPACE modeshape WITH replication "
              + "= {'class':'SimpleStrategy', 'replication_factor':3};");
    } catch (AlreadyExistsException e) {
    }

    session.execute("USE modeshape;");

    try {
      session.execute(
          "CREATE TABLE modeshape.binary("
              + "cid text PRIMARY KEY,"
              + "mime_type text,"
              + "ext_text text,"
              + "usage int,"
              + "usage_time timestamp,"
              + "payload blob)");
    } catch (AlreadyExistsException e) {
    }

    try {
      session.execute("CREATE INDEX USAGE_IDX ON modeshape.binary (usage);");
    } catch (InvalidQueryException e) {
      // exists
    }

    try {
      session.execute("CREATE INDEX EXPIRE_IDX ON modeshape.binary (usage_time);");
    } catch (InvalidQueryException e) {
      // exists
    }
  }
  public static String[] getHosts(Cluster cluster) {

    if (cluster == null) {
      System.out.println("Creating cluster connection");
      cluster = Cluster.builder().addContactPoint(Host).build();
    }
    System.out.println("Cluster Name " + cluster.getClusterName());
    Metadata mdata = cluster.getMetadata();
    Set<Host> hosts = mdata.getAllHosts();
    String sHosts[] = new String[hosts.size()];

    Iterator<Host> it = hosts.iterator();
    int i = 0;
    while (it.hasNext()) {
      Host ch = it.next();
      sHosts[i] = (String) ch.getAddress().toString();

      System.out.println("Hosts" + ch.getAddress().toString());
      i++;
    }

    return sHosts;
  }
  public static Cluster createCluster(CassandraConfiguration config) throws DataSourceException {

    boolean debugEnabled = false;
    if (log.isDebugEnabled()) {
      debugEnabled = true;
    }

    String userName = config.getUsername();
    String password = config.getPassword();
    List<String> connections = config.getHosts();
    String clusterName = config.getClusterName();
    int port = config.getPort();
    boolean jmxDisabled = config.getJmxDisabled();

    if (userName == null || password == null) {
      throw new DataSourceException("Can't create cluster with empty userName or Password");
    }

    if (clusterName == null) {
      throw new DataSourceException("Can't create cluster with empty cluster name");
    }

    if (connections == null || connections.isEmpty()) {
      throw new DataSourceException("Can't create cluster with empty connection string");
    }

    int maxConnections = config.getMaxConnections();
    int concurrency = config.getConcurrency();
    boolean async = config.getAsync();
    String compression = config.getCompression();

    StringBuilder configProps = new StringBuilder();
    configProps
        .append("  concurrency:          " + concurrency)
        .append("\n  mode:                 " + (async ? "asynchronous" : "blocking"))
        .append("\n  per-host connections: " + maxConnections)
        .append("\n  compression:          " + compression);

    if (debugEnabled) {
      log.debug(configProps.toString());
    }

    Cluster cluster = null;

    try {
      PoolingOptions poolOptions = CassandraDatasourceUtils.createPoolingOptions(config);
      SocketOptions socketOptions = CassandraDatasourceUtils.createSocketOptions(config);

      // Create cluster

      Builder builder = Cluster.builder();

      for (String con : connections) {
        builder.addContactPoints(con);
      }
      builder
          .withPoolingOptions(poolOptions)
          .withSocketOptions(socketOptions)
          .withPort(port)
          .withCredentials(userName, password);

      CassandraDatasourceUtils.createRetryPolicy(config, builder);
      CassandraDatasourceUtils.createReconnectPolicy(config, builder);
      CassandraDatasourceUtils.createLoadBalancingPolicy(config, builder);
      if (jmxDisabled) {
        builder.withoutMetrics();
        builder.withoutJMXReporting();
      }

      if (ProtocolOptions.Compression.SNAPPY.name().equalsIgnoreCase(compression)) {
        builder.withCompression(ProtocolOptions.Compression.SNAPPY);
      } else {
        builder.withCompression(ProtocolOptions.Compression.NONE);
      }

      cluster = builder.build();

      // validate cluster information after connect
      StringBuilder metaDataAfterConnect = new StringBuilder();
      Set<Host> allHosts = cluster.getMetadata().getAllHosts();
      for (Host h : allHosts) {
        metaDataAfterConnect.append("[");
        metaDataAfterConnect.append(h.getDatacenter());
        metaDataAfterConnect.append("-");
        metaDataAfterConnect.append(h.getRack());
        metaDataAfterConnect.append("-");
        metaDataAfterConnect.append(h.getAddress());
        metaDataAfterConnect.append("]\n");
      }

      if (debugEnabled) {
        log.debug("Cassandra Cluster: " + metaDataAfterConnect.toString());
      }

    } catch (NoHostAvailableException ex) {
      throw new DataSourceException(" No Host available to access ", ex);
    } catch (Exception ex) {
      throw new DataSourceException(" Can not create cluster ", ex);
    }

    return cluster;
  }