Java States.CLOSED屬性代碼示例

@Override
public void shutdown(int exitCode) {
    try {
        // Try to close ZK session to ensure all ephemeral locks gets released immediately
        if (service != null) {
            if (service.getZkClient().getState() != States.CLOSED) {
                service.getZkClient().close();
            }
        }
    } catch (Exception e) {
        LOG.warn(e.getMessage(), e);
    }

    LOG.info("Invoking Runtime.halt({})", exitCode);
    immediateFlushBufferedLogs();
    Runtime.getRuntime().halt(exitCode);

}
 

@Override
public void process(WatchedEvent event) {
    ZooKeeperExtended   _zk;
    
    _zk = _getZooKeeper(); 
    if (_zk == null || _zk.getState() == States.CLOSED) {
        handleSessionExpiration();
    }
    //Log.warning(event.toString());
    synchronized (this) {
        this.notifyAll();
    }
    if (watcher != null) {
        watcher.process(event);
    }
}
 

/**
 * @see org.apache.zookeeper.ZooKeeper#getState()
 */
public States getState() {
    if (_ZooKeeper == null) {
        return States.CLOSED;
    }

    return _ZooKeeper.getState();
}
 

/**
 * 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));
}
 

/**
 * 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));
}
 

private void handleSessionExpiration() {
    Lock    lock;
    
    lock = acquireLockIfShared(zkConfig);
    
    try {
        boolean             established;
        
        established = false;        
        while (!established) {
            ZooKeeperExtended   _zk;
            
            ThreadUtil.sleepSeconds(connectionLossSleepSeconds);
            _zk = zkMap.get(zkConfig);
            if (_zk != null && _zk.getState() != States.CLOSED) {
                established = true;
            } else {
                zkMap.remove(zkConfig);
                try {
                    Log.warning(String.format("Attempting to reestablish session %s\n", zkConfig));
                    zk = ZooKeeperExtended.getZooKeeperWithRetries(zkConfig, sessionTimeout, this, connectAttempts);
                    Log.warning(String.format("Session restablished %s\n", zkConfig));
                    established = true;
                    if (shareZK) {
                        zkMap.put(zkConfig, zk);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    } finally {
        releaseLockIfShared(lock);
    }
}
 

void close() {
    state = States.CLOSED;
    clientCnxnSocket.wakeupCnxn();
}
 

void close() {
    state = States.CLOSED;
    clientCnxnSocket.onClosing();
}
 

/**
 * 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();
}