Java States.CONNECTED屬性代碼示例

/**
 * Checks whether the broker is allowed to do read-write operations based on the existence of a node in global
 * zookeeper.
 *
 * @throws WebApplicationException
 *             if broker has a read only access if broker is not connected to the global zookeeper
 */
public void validatePoliciesReadOnlyAccess() {
    boolean arePoliciesReadOnly = true;

    try {
        arePoliciesReadOnly = globalZkCache().exists(POLICIES_READONLY_FLAG_PATH);
    } catch (Exception e) {
        log.warn("Unable to fetch contents of [{}] from global zookeeper", POLICIES_READONLY_FLAG_PATH, e);
        throw new RestException(e);
    }

    if (arePoliciesReadOnly) {
        log.debug("Policies are read-only. Broker cannot do read-write operations");
        throw new RestException(Status.FORBIDDEN, "Broker is forbidden to do read-write operations");
    } else {
        // Make sure the broker is connected to the global zookeeper before writing. If not, throw an exception.
        if (globalZkCache().getZooKeeper().getState() != States.CONNECTED) {
            log.debug("Broker is not connected to the global zookeeper");
            throw new RestException(Status.PRECONDITION_FAILED,
                    "Broker needs to be connected to global zookeeper before making a read-write operation");
        } else {
            // Do nothing, just log the message.
            log.debug("Broker is allowed to make read-write operations");
        }
    }
}
 

/**
 * Callback invoked by the ClientCnxnSocket once a connection has been
 * established.
 * 
 * @param _negotiatedSessionTimeout
 * @param _sessionId
 * @param _sessionPasswd
 * @param isRO
 * @throws IOException
 */
void onConnected(int _negotiatedSessionTimeout, long _sessionId,
        byte[] _sessionPasswd, boolean isRO) throws IOException {
    negotiatedSessionTimeout = _negotiatedSessionTimeout;
    if (negotiatedSessionTimeout <= 0) {
        state = States.CLOSED;

        eventThread.queueEvent(new WatchedEvent(
                Watcher.Event.EventType.None,
                Watcher.Event.KeeperState.Expired, null));
        eventThread.queueEventOfDeath();

        String warnInfo;
        warnInfo = "Unable to reconnect to ZooKeeper service, session 0x"
            + Long.toHexString(sessionId) + " has expired";
        LOG.warn(warnInfo);
        throw new SessionExpiredException(warnInfo);
    }
    if (!readOnly && isRO) {
        LOG.error("Read/write client got connected to read-only server");
    }
    readTimeout = negotiatedSessionTimeout * 2 / 3;
    connectTimeout = negotiatedSessionTimeout / hostProvider.size();
    hostProvider.onConnected();
    sessionId = _sessionId;
    sessionPasswd = _sessionPasswd;
    state = (isRO) ?
            States.CONNECTEDREADONLY : States.CONNECTED;
    seenRwServerBefore |= !isRO;
    LOG.info("Session establishment complete on server "
            + clientCnxnSocket.getRemoteSocketAddress()
            + ", sessionid = 0x" + Long.toHexString(sessionId)
            + ", negotiated timeout = " + negotiatedSessionTimeout
            + (isRO ? " (READ-ONLY mode)" : ""));
    KeeperState eventState = (isRO) ?
            KeeperState.ConnectedReadOnly : KeeperState.SyncConnected;
    eventThread.queueEvent(new WatchedEvent(
            Watcher.Event.EventType.None,
            eventState, null));
}
 

synchronized private boolean waitForConnect(ZooKeeper zk, long timeout) throws InterruptedException {
    connected = (zk.getState() == States.CONNECTED);
    long end = System.currentTimeMillis() + timeout;
    while(!connected && end > System.currentTimeMillis()) {
        wait(timeout);
        connected = (zk.getState() == States.CONNECTED);
    }
    return connected;
}
 

synchronized private boolean waitForConnect(ZooKeeper zk, long timeout) throws InterruptedException {
    connected = (zk.getState() == States.CONNECTED);
    long end = Time.currentElapsedTime() + timeout;
    while(!connected && end > Time.currentElapsedTime()) {
        wait(timeout);
        connected = (zk.getState() == States.CONNECTED);
    }
    return connected;
}
 

/**
 * Callback invoked by the ClientCnxnSocket once a connection has been
 * established.
 * 
 * @param _negotiatedSessionTimeout
 * @param _sessionId
 * @param _sessionPasswd
 * @param isRO
 * @throws IOException
 */
void onConnected(int _negotiatedSessionTimeout, long _sessionId,
        byte[] _sessionPasswd, boolean isRO) throws IOException {
    negotiatedSessionTimeout = _negotiatedSessionTimeout;
    if (negotiatedSessionTimeout <= 0) {
        state = States.CLOSED;

        eventThread.queueEvent(new WatchedEvent(
                Watcher.Event.EventType.None,
                Watcher.Event.KeeperState.Expired, null));
        eventThread.queueEventOfDeath();
        throw new SessionExpiredException(
                "Unable to reconnect to ZooKeeper service, session 0x"
                        + Long.toHexString(sessionId) + " has expired");
    }
    if (!readOnly && isRO) {
        LOG.error("Read/write client got connected to read-only server");
    }
    readTimeout = negotiatedSessionTimeout * 2 / 3;
    connectTimeout = negotiatedSessionTimeout / hostProvider.size();
    hostProvider.onConnected();
    sessionId = _sessionId;
    sessionPasswd = _sessionPasswd;
    state = (isRO) ?
            States.CONNECTEDREADONLY : States.CONNECTED;
    seenRwServerBefore |= !isRO;
    LOG.info("Session establishment complete on server "
            + clientCnxnSocket.getRemoteSocketAddress()
            + ", sessionid = 0x" + Long.toHexString(sessionId)
            + ", negotiated timeout = " + negotiatedSessionTimeout
            + (isRO ? " (READ-ONLY mode)" : ""));
    KeeperState eventState = (isRO) ?
            KeeperState.ConnectedReadOnly : KeeperState.SyncConnected;
    eventThread.queueEvent(new WatchedEvent(
            Watcher.Event.EventType.None,
            eventState, null));
}
 

/**
 * Callback invoked by the ClientCnxnSocket once a connection has been
 * established.
 *
 * @param _negotiatedSessionTimeout
 * @param _sessionId
 * @param _sessionPasswd
 * @param isRO
 * @throws IOException
 */
void onConnected(int _negotiatedSessionTimeout, long _sessionId,
                 byte[] _sessionPasswd, boolean isRO) throws IOException {
    negotiatedSessionTimeout = _negotiatedSessionTimeout;
    if (negotiatedSessionTimeout <= 0) {
        state = States.CLOSED;

        eventThread.queueEvent(new WatchedEvent(
                Watcher.Event.EventType.None,
                Watcher.Event.KeeperState.Expired, null));
        eventThread.queueEventOfDeath();
        throw new SessionExpiredException(
                "Unable to reconnect to ZooKeeper service, session 0x"
                        + Long.toHexString(sessionId) + " has expired");
    }
    if (!readOnly && isRO) {
        LOG.error("Read/write client got connected to read-only server");
    }
    readTimeout = negotiatedSessionTimeout * 2 / 3;
    connectTimeout = negotiatedSessionTimeout / hostProvider.size();
    hostProvider.onConnected();
    sessionId = _sessionId;
    sessionPasswd = _sessionPasswd;
    state = (isRO) ?
            States.CONNECTEDREADONLY : States.CONNECTED;
    seenRwServerBefore |= !isRO;
    LOG.info("Session establishment complete on server "
            + clientCnxnSocket.getRemoteSocketAddress()
            + ", sessionid = 0x" + Long.toHexString(sessionId)
            + ", negotiated timeout = " + negotiatedSessionTimeout
            + (isRO ? " (READ-ONLY mode)" : ""));
    KeeperState eventState = (isRO) ?
            KeeperState.ConnectedReadOnly : KeeperState.SyncConnected;
    eventThread.queueEvent(new WatchedEvent(
            Watcher.Event.EventType.None,
            eventState, null));
}
 

public ManagedLedgerFactoryImpl(ClientConfiguration bkClientConfiguration, ManagedLedgerFactoryConfig config)
        throws Exception {
    final CountDownLatch counter = new CountDownLatch(1);
    final String zookeeperQuorum = checkNotNull(bkClientConfiguration.getZkServers());

    zookeeper = new ZooKeeper(zookeeperQuorum, bkClientConfiguration.getZkTimeout(), event -> {
        if (event.getState().equals(Watcher.Event.KeeperState.SyncConnected)) {
            log.info("Connected to zookeeper");
            counter.countDown();
        } else {
            log.error("Error connecting to zookeeper {}", event);
        }
    });

    if (!counter.await(bkClientConfiguration.getZkTimeout(), TimeUnit.MILLISECONDS)
            || zookeeper.getState() != States.CONNECTED) {
        throw new ManagedLedgerException("Error connecting to ZooKeeper at '" + zookeeperQuorum + "'");
    }

    this.bookKeeper = new BookKeeper(bkClientConfiguration, zookeeper);
    this.isBookkeeperManaged = true;

    this.store = new MetaStoreImplZookeeper(zookeeper, orderedExecutor);

    this.config = config;
    this.mbean = new ManagedLedgerFactoryMBeanImpl(this);
    this.entryCacheManager = new EntryCacheManager(this);
    this.statsTask = executor.scheduleAtFixedRate(() -> refreshStats(), 0, StatsPeriodSeconds, TimeUnit.SECONDS);
}
 

private synchronized ZooKeeper getZooKeeper() {
  if (_zk == null || _zk.getState() != States.CONNECTED) {
    try {
      latch = new CountDownLatch(1);
      _zk = new ZooKeeper(this.connection, this.sessionTimeoutMs, this);
      latch.await();
    } catch (Exception e) {
      throw new RuntimeException("Could not connect to ZooKeeper output: " + e.getMessage());
    }
  }
  
  return _zk;
}
 

public boolean checkZookeeperState() throws Exception{
	return zk != null && zk.getState() == States.CONNECTED;
}
 

public boolean checkZookeeperState() throws Exception {
    return zk != null && zk.getState() == States.CONNECTED;
}
 

/**
 * See HBASE-1232 and http://wiki.apache.org/hadoop/ZooKeeper/FAQ#4.
 * @throws IOException
 * @throws InterruptedException
 */
// fails frequently, disabled for now, see HBASE-6406
//@Test
public void testClientSessionExpired() throws Exception {
  Configuration c = new Configuration(TEST_UTIL.getConfiguration());

  // We don't want to share the connection as we will check its state
  c.set(HConstants.HBASE_CLIENT_INSTANCE_ID, "1111");

  HConnection connection = HConnectionManager.getConnection(c);

  ZooKeeperWatcher connectionZK = getZooKeeperWatcher(connection);
  LOG.info("ZooKeeperWatcher= 0x"+ Integer.toHexString(
    connectionZK.hashCode()));
  LOG.info("getRecoverableZooKeeper= 0x"+ Integer.toHexString(
    connectionZK.getRecoverableZooKeeper().hashCode()));
  LOG.info("session="+Long.toHexString(
    connectionZK.getRecoverableZooKeeper().getSessionId()));

  TEST_UTIL.expireSession(connectionZK);

  LOG.info("Before using zkw state=" +
    connectionZK.getRecoverableZooKeeper().getState());
  // provoke session expiration by doing something with ZK
  try {
    connectionZK.getRecoverableZooKeeper().getZooKeeper().exists(
      "/1/1", false);
  } catch (KeeperException ignored) {
  }

  // Check that the old ZK connection is closed, means we did expire
  States state = connectionZK.getRecoverableZooKeeper().getState();
  LOG.info("After using zkw state=" + state);
  LOG.info("session="+Long.toHexString(
    connectionZK.getRecoverableZooKeeper().getSessionId()));

  // It's asynchronous, so we may have to wait a little...
  final long limit1 = System.currentTimeMillis() + 3000;
  while (System.currentTimeMillis() < limit1 && state != States.CLOSED){
    state = connectionZK.getRecoverableZooKeeper().getState();
  }
  LOG.info("After using zkw loop=" + state);
  LOG.info("ZooKeeper should have timed out");
  LOG.info("session="+Long.toHexString(
    connectionZK.getRecoverableZooKeeper().getSessionId()));

  // It's surprising but sometimes we can still be in connected state.
  // As it's known (even if not understood) we don't make the the test fail
  // for this reason.)
  // Assert.assertTrue("state=" + state, state == States.CLOSED);

  // Check that the client recovered
  ZooKeeperWatcher newConnectionZK = getZooKeeperWatcher(connection);

  States state2 = newConnectionZK.getRecoverableZooKeeper().getState();
  LOG.info("After new get state=" +state2);

  // As it's an asynchronous event we may got the same ZKW, if it's not
  //  yet invalidated. Hence this loop.
  final long limit2 = System.currentTimeMillis() + 3000;
  while (System.currentTimeMillis() < limit2 &&
    state2 != States.CONNECTED && state2 != States.CONNECTING) {

    newConnectionZK = getZooKeeperWatcher(connection);
    state2 = newConnectionZK.getRecoverableZooKeeper().getState();
  }
  LOG.info("After new get state loop=" + state2);

  Assert.assertTrue(
    state2 == States.CONNECTED || state2 == States.CONNECTING);

  connection.close();
}
 

/**
 * Expire a ZooKeeper session as recommended in ZooKeeper documentation
 * http://wiki.apache.org/hadoop/ZooKeeper/FAQ#A4
 * There are issues when doing this:
 * [1] http://www.mail-archive.com/[email protected]/msg01942.html
 * [2] https://issues.apache.org/jira/browse/ZOOKEEPER-1105
 *
 * @param nodeZK - the ZK watcher to expire
 * @param checkStatus - true to check if we can create an HTable with the
 *                    current configuration.
 */
public void expireSession(ZooKeeperWatcher nodeZK, boolean checkStatus)
  throws Exception {
  Configuration c = new Configuration(this.conf);
  String quorumServers = ZKConfig.getZKQuorumServersString(c);
  ZooKeeper zk = nodeZK.getRecoverableZooKeeper().getZooKeeper();
  byte[] password = zk.getSessionPasswd();
  long sessionID = zk.getSessionId();

  // Expiry seems to be asynchronous (see comment from P. Hunt in [1]),
  //  so we create a first watcher to be sure that the
  //  event was sent. We expect that if our watcher receives the event
  //  other watchers on the same machine will get is as well.
  // When we ask to close the connection, ZK does not close it before
  //  we receive all the events, so don't have to capture the event, just
  //  closing the connection should be enough.
  ZooKeeper monitor = new ZooKeeper(quorumServers,
    1000, new org.apache.zookeeper.Watcher(){
    @Override
    public void process(WatchedEvent watchedEvent) {
      LOG.info("Monitor ZKW received event="+watchedEvent);
    }
  } , sessionID, password);

  // Making it expire
  ZooKeeper newZK = new ZooKeeper(quorumServers,
      1000, EmptyWatcher.instance, sessionID, password);

  //ensure that we have connection to the server before closing down, otherwise
  //the close session event will be eaten out before we start CONNECTING state
  long start = System.currentTimeMillis();
  while (newZK.getState() != States.CONNECTED
       && System.currentTimeMillis() - start < 1000) {
     Thread.sleep(1);
  }
  newZK.close();
  LOG.info("ZK Closed Session 0x" + Long.toHexString(sessionID));

  // Now closing & waiting to be sure that the clients get it.
  monitor.close();

  if (checkStatus) {
    new HTable(new Configuration(conf), TableName.META_TABLE_NAME).close();
  }
}
 

public boolean checkZookeeperState() throws Exception{
    return zk != null && zk.getState() == States.CONNECTED;
}
 

/**
 * Returns <code>true</code> if the connection is currently established.
 * 
 * @return <code>true</code> if the connection is currently established.
 */
public boolean isConnected() {
    return (getState() == States.CONNECTED);
}