Ejemplo n.º 1
0
 /**
  * Shutdown this session instance, only waiting a definite amount of time.
  *
  * <p>This closes all connections used by this sessions. Note that if you want to shutdown the
  * full {@code Cluster} instance this session is part of, you should use {@link Cluster#shutdown}
  * instead (which will call this method for all session but also release some additional
  * resources).
  *
  * <p>Note that this method is not thread safe in the sense that if another shutdown is perform in
  * parallel, it might return {@code true} even if the instance is not yet fully shutdown.
  *
  * @param timeout how long to wait for the session to shutdown.
  * @param unit the unit for the timeout.
  * @return {@code true} if the session has been properly shutdown within the {@code timeout},
  *     {@code false} otherwise.
  */
 public boolean shutdown(long timeout, TimeUnit unit) {
   try {
     return manager.shutdown(timeout, unit);
   } catch (InterruptedException e) {
     Thread.currentThread().interrupt();
     return false;
   }
 }
Ejemplo n.º 2
0
    public Manager(Cluster cluster, Collection<Host> hosts) {
      this.cluster = cluster;

      this.pools = new ConcurrentHashMap<Host, HostConnectionPool>(hosts.size());
      this.poolsState = new HostConnectionPool.PoolState();

      // Create pool to initial nodes (and wait for them to be created)
      for (Host host : hosts) {
        try {
          addOrRenewPool(host).get();
        } catch (ExecutionException e) {
          // This is not supposed to happen
          throw new DriverInternalError(e);
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
        }
      }
    }
Ejemplo n.º 3
0
  private PreparedStatement toPreparedStatement(String query, Connection.Future future) {

    try {
      Message.Response response = Uninterruptibles.getUninterruptibly(future);
      switch (response.type) {
        case RESULT:
          ResultMessage rm = (ResultMessage) response;
          switch (rm.kind) {
            case PREPARED:
              ResultMessage.Prepared pmsg = (ResultMessage.Prepared) rm;
              PreparedStatement stmt =
                  PreparedStatement.fromMessage(
                      pmsg, manager.cluster.getMetadata(), query, manager.poolsState.keyspace);
              try {
                manager.cluster.manager.prepare(pmsg.statementId, stmt, future.getAddress());
              } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                // This method doesn't propagate interruption, at least not for now. However, if
                // we've
                // interrupted preparing queries on other node it's not a problem as we'll
                // re-prepare
                // later if need be. So just ignore.
              }
              return stmt;
            default:
              throw new DriverInternalError(
                  String.format(
                      "%s response received when prepared statement was expected", rm.kind));
          }
        case ERROR:
          ResultSetFuture.extractCause(
              ResultSetFuture.convertException(((ErrorMessage) response).error));
          break;
        default:
          throw new DriverInternalError(
              String.format(
                  "%s response received when prepared statement was expected", response.type));
      }
      throw new AssertionError();
    } catch (ExecutionException e) {
      ResultSetFuture.extractCauseFromExecutionException(e);
      throw new AssertionError();
    }
  }