org.I0Itec.zkclient.exception.ZkInterruptedException Java Examples

public boolean waitUntilExists(String path, TimeUnit timeUnit, long time) throws ZkInterruptedException {
    Date timeout = new Date(System.currentTimeMillis() + timeUnit.toMillis(time));
    LOG.debug("Waiting until znode '" + path + "' becomes available.");
    if (exists(path)) {
        return true;
    }
    acquireEventLock();
    try {
        while (!exists(path, true)) {
            boolean gotSignal = getEventLock().getZNodeEventCondition().awaitUntil(timeout);
            if (!gotSignal) {
                return false;
            }
        }
        return true;
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    } finally {
        getEventLock().unlock();
    }
}
 

/**
 * Create a persistent Sequential node.
 *
 * @param path
 * @param data
 * @param createParents if true all parent dirs are created as well and no
 * {@link ZkNodeExistsException} is thrown in case the path already exists
 * @throws ZkInterruptedException if operation was interrupted, or a
 * required reconnection got interrupted
 * @throws IllegalArgumentException if called from anything except the
 * ZooKeeper event thread
 * @throws ZkException if any ZooKeeper exception occurred
 * @throws RuntimeException if any other exception occurs
 */
public String createPersistentSequential(String path, Object data, boolean createParents)
                                                                                         throws ZkInterruptedException,
                                                                                         IllegalArgumentException,
                                                                                         ZkException,
                                                                                         RuntimeException {
    try {
        return create(path, data, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (ZkNoNodeException e) {
        if (!createParents) {
            throw e;
        }
        String parentDir = path.substring(0, path.lastIndexOf('/'));
        createPersistent(parentDir, createParents);
        return createPersistentSequential(path, data, createParents);
    }
}
 

public boolean waitUntilExists(String path, TimeUnit timeUnit, long time) throws ZkInterruptedException {
    Date timeout = new Date(System.currentTimeMillis() + timeUnit.toMillis(time));
    LOG.debug("Waiting until znode '" + path + "' becomes available.");
    if (exists(path)) {
        return true;
    }
    acquireEventLock();
    try {
        while (!exists(path, true)) {
            boolean gotSignal = getEventLock().getZNodeEventCondition().awaitUntil(timeout);
            if (!gotSignal) {
                return false;
            }
        }
        return true;
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    } finally {
        getEventLock().unlock();
    }
}
 

/**
 * Connect to ZooKeeper.
 *
 * @param maxMsToWaitUntilConnected
 * @param watcher
 * @throws ZkInterruptedException
 *             if the connection timed out due to thread interruption
 * @throws ZkTimeoutException
 *             if the connection timed out
 * @throws IllegalStateException
 *             if the connection timed out due to thread interruption
 */
public void connect(final long maxMsToWaitUntilConnected, Watcher watcher) throws ZkInterruptedException, ZkTimeoutException, IllegalStateException {
    boolean started = false;
    acquireEventLock();
    try {
        setShutdownTrigger(false);
        _eventThread = new ZkEventThread(_connection.getServers());
        _eventThread.start();
        _connection.connect(watcher);

        LOG.debug("Awaiting connection to Zookeeper server");
        boolean waitSuccessful = waitUntilConnected(maxMsToWaitUntilConnected, TimeUnit.MILLISECONDS);
        if (!waitSuccessful) {
            throw new ZkTimeoutException("Unable to connect to zookeeper server '" + _connection.getServers() + "' with timeout of " + maxMsToWaitUntilConnected + " ms");
        }
        started = true;
    } finally {
        getEventLock().unlock();

        // we should close the zookeeper instance, otherwise it would keep
        // on trying to connect
        if (!started) {
            close();
        }
    }
}
 

/**
 * Close the client.
 *
 * @throws ZkInterruptedException
 */
public void close() throws ZkInterruptedException {
    if (_closed) {
        return;
    }
    LOG.debug("Closing ZkClient...");
    getEventLock().lock();
    try {
        setShutdownTrigger(true);
        _eventThread.interrupt();
        _eventThread.join(2000);
        _connection.close();
        _closed = true;
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    } finally {
        getEventLock().unlock();
    }
    LOG.debug("Closing ZkClient...done");
}
 

/**
 * Create a persistent Sequential node.
 *
 * @param path
 * @param data
 * @param createParents if true all parent dirs are created as well and no
 * {@link ZkNodeExistsException} is thrown in case the path already exists
 * @throws ZkInterruptedException if operation was interrupted, or a
 * required reconnection got interrupted
 * @throws IllegalArgumentException if called from anything except the
 * ZooKeeper event thread
 * @throws ZkException if any ZooKeeper exception occurred
 * @throws RuntimeException if any other exception occurs
 */
public String createPersistentSequential(String path, Object data, boolean createParents)
                                                                                         throws ZkInterruptedException,
                                                                                         IllegalArgumentException,
                                                                                         ZkException,
                                                                                         RuntimeException {
    try {
        return create(path, data, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (ZkNoNodeException e) {
        if (!createParents) {
            throw e;
        }
        String parentDir = path.substring(0, path.lastIndexOf('/'));
        createPersistent(parentDir, createParents);
        return createPersistentSequential(path, data, createParents);
    }
}
 

/**
 * Create a persistent Sequential node.
 *
 * @param path
 * @param data
 * @param createParents if true all parent dirs are created as well and no
 *                      {@link ZkNodeExistsException} is thrown in case the path already exists
 * @throws ZkInterruptedException   if operation was interrupted, or a
 *                                  required reconnection got interrupted
 * @throws IllegalArgumentException if called parseFrom anything except the
 *                                  ZooKeeper event thread
 * @throws ZkException              if any ZooKeeper errors occurred
 * @throws RuntimeException         if any other errors occurs
 */
public String createPersistentSequential(String path, Object data, boolean createParents)
        throws ZkInterruptedException,
        IllegalArgumentException,
        ZkException,
        RuntimeException {
    try {
        return create(path, data, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (ZkNoNodeException e) {
        if (!createParents) {
            throw e;
        }
        String parentDir = path.substring(0, path.lastIndexOf('/'));
        createPersistent(parentDir, createParents);
        return createPersistentSequential(path, data, createParents);
    }
}
 

/**
 * Close the client.
 *
 * @throws ZkInterruptedException
 */
public void close() throws ZkInterruptedException {
    if (_closed) {
        return;
    }
    LOG.debug("Closing ZkClient...");
    getEventLock().lock();
    try {
        setShutdownTrigger(true);
        _eventThread.interrupt();
        _eventThread.join(2000);
        _connection.close();
        _closed = true;
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    } finally {
        getEventLock().unlock();
    }
    LOG.debug("Closing ZkClient...done");
}
 

/**
 * Connect to ZooKeeper.
 *
 * @param maxMsToWaitUntilConnected
 * @param watcher
 * @throws ZkInterruptedException
 *             if the connection timed out due to thread interruption
 * @throws ZkTimeoutException
 *             if the connection timed out
 * @throws IllegalStateException
 *             if the connection timed out due to thread interruption
 */
public void connect(final long maxMsToWaitUntilConnected, Watcher watcher) throws ZkInterruptedException, ZkTimeoutException, IllegalStateException {
    boolean started = false;
    acquireEventLock();
    try {
        setShutdownTrigger(false);
        _eventThread = new ZkEventThread(_connection.getServers());
        _eventThread.start();
        _connection.connect(watcher);

        LOG.debug("Awaiting connection to Zookeeper server");
        boolean waitSuccessful = waitUntilConnected(maxMsToWaitUntilConnected, TimeUnit.MILLISECONDS);
        if (!waitSuccessful) {
            throw new ZkTimeoutException("Unable to connect to zookeeper server '" + _connection.getServers() + "' with timeout of " + maxMsToWaitUntilConnected + " ms");
        }
        started = true;
    } finally {
        getEventLock().unlock();

        // we should close the zookeeper instance, otherwise it would keep
        // on trying to connect
        if (!started) {
            close();
        }
    }
}
 

private void acquireEventLock() {
    try {
        getEventLock().lockInterruptibly();
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    }
}
 

public boolean waitUntilConnected(long time, TimeUnit timeUnit) throws ZkInterruptedException {
    if (_isZkSaslEnabled) {
        return waitForKeeperState(KeeperState.SaslAuthenticated, time, timeUnit);
    } else {
        return waitForKeeperState(KeeperState.SyncConnected, time, timeUnit);
    }
}
 

@Override
protected void postShutdownHook() {
  if (_enablePartitionAssignment) {
    boolean resetInterrupted = false;
    try {
      for (int numAttempts = 1; numAttempts <= 3; ++numAttempts) {
        try {
          // The task lock should only be released when it is absolutely safe (we can guarantee that the task cannot
          // consume any further). The shutdown process must complete and the consumer must be closed.
          LOG.info("Releasing the lock on datastreamTask: {}, was thread interrupted: {}, attempt: {}",
              _datastreamTask, resetInterrupted, numAttempts);
          _datastreamTask.release();
          break;
        } catch (ZkInterruptedException e) {
          LOG.warn("Releasing the task lock failed for datastreamTask: {}, retrying", _datastreamTask);
          if (Thread.currentThread().isInterrupted()) {
            // The interrupted status of the current thread must be reset to allow the task lock to be released
            resetInterrupted = Thread.interrupted();
          }
        }
      }
    } finally {
      if (resetInterrupted) {
        // Setting the status of the thread back to interrupted
        Thread.currentThread().interrupt();
      }
    }
  }
}
 

public boolean waitForKeeperState(KeeperState keeperState, long time, TimeUnit timeUnit) throws ZkInterruptedException {
    if (_zookeeperEventThread != null && Thread.currentThread() == _zookeeperEventThread) {
        throw new IllegalArgumentException("Must not be done in the zookeeper event thread.");
    }
    Date timeout = new Date(System.currentTimeMillis() + timeUnit.toMillis(time));

    LOG.info("Waiting for keeper state " + keeperState);
    acquireEventLock();
    try {
        boolean stillWaiting = true;
        while (_currentState != keeperState) {
            if (!stillWaiting) {
                return false;
            }
            stillWaiting = getEventLock().getStateChangedCondition().awaitUntil(timeout);
            // Throw an exception in the case authorization fails
            if (_currentState == KeeperState.AuthFailed && _isZkSaslEnabled) {
                throw new ZkAuthFailedException("Authentication failure");
            }
        }
        LOG.debug("State is " + _currentState);
        return true;
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    } finally {
        getEventLock().unlock();
    }
}
 

public boolean waitUntilConnected(long time, TimeUnit timeUnit) throws ZkInterruptedException {
    if (_isZkSaslEnabled) {
        return waitForKeeperState(KeeperState.SaslAuthenticated, time, timeUnit);
    } else {
        return waitForKeeperState(KeeperState.SyncConnected, time, timeUnit);
    }
}
 

@Override
public void close() throws ZkInterruptedException {
  if (LOG.isTraceEnabled()) {
    StackTraceElement[] calls = Thread.currentThread().getStackTrace();
    LOG.trace("closing zkclient. callStack: {}", Arrays.asList(calls));
  }
  getEventLock().lock();
  try {
    if (_connection == null) {
      return;
    }
    LOG.info("closing zkclient: {}", ((ZkConnection) _connection).getZookeeper());
    super.close();
  } catch (ZkInterruptedException e) {
    /*
     * Workaround for HELIX-264: calling ZkClient#disconnect() in its own eventThread context will
     * throw ZkInterruptedException and skip ZkConnection#disconnect()
     */
    try {
      /*
       * ZkInterruptedException#construct() honors InterruptedException by calling
       * Thread.currentThread().interrupt(); clear it first, so we can safely disconnect the
       * zk-connection
       */
      Thread.interrupted();
      _connection.close();
      /*
       * restore interrupted status of current thread
       */
      Thread.currentThread().interrupt();
    } catch (InterruptedException e1) {
      throw new ZkInterruptedException(e1);
    }
  } finally {
    getEventLock().unlock();
    LOG.info("closed zkclient");
  }
}
 

/**
    * 创建一个持久的顺序节点
    */
public String createPersistentSequential(String path, boolean createParents)
		throws ZkInterruptedException, IllegalArgumentException, ZkException, RuntimeException {
       try {
           return create(path, null, CreateMode.PERSISTENT_SEQUENTIAL);
       } catch (ZkNoNodeException e) {
           if (!createParents) {
               throw e;
           }
           String parentDir = path.substring(0, path.lastIndexOf('/'));
           createPersistent(parentDir, createParents);
           return createPersistentSequential(path, createParents);
       }
   }
 

public String createPersistentSequential(String path, Object data, boolean createParents)
throws ZkInterruptedException, IllegalArgumentException, ZkException, RuntimeException {
     try {
         return create(path, data, CreateMode.PERSISTENT_SEQUENTIAL);
     } catch (ZkNoNodeException e) {
         if (!createParents) {
             throw e;
         }
         String parentDir = path.substring(0, path.lastIndexOf('/'));
         createPersistent(parentDir, createParents);
         return createPersistentSequential(path, data, createParents);
     }
 }
 

public void connect() throws ZkInterruptedException {
  boolean isConnected = zkClient.waitUntilConnected(connectionTimeoutMs, TimeUnit.MILLISECONDS);
  if (!isConnected) {
    metrics.zkConnectionError.inc();
    throw new RuntimeException("Unable to connect to Zookeeper within connectionTimeout " + connectionTimeoutMs + "ms. Shutting down!");
  }
}
 

/**
 * Create a persistent Sequential node.
 *
 * @param path
 * @param createParents if true all parent dirs are created as well and no
 * {@link ZkNodeExistsException} is thrown in case the path already exists
 * @throws ZkInterruptedException if operation was interrupted, or a
 * required reconnection got interrupted
 * @throws IllegalArgumentException if called from anything except the
 * ZooKeeper event thread
 * @throws ZkException if any ZooKeeper exception occurred
 * @throws RuntimeException if any other exception occurs
 */
public String createPersistentSequential(String path, boolean createParents) throws ZkInterruptedException,
                                                                            IllegalArgumentException, ZkException,
                                                                            RuntimeException {
    try {
        return create(path, null, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (ZkNoNodeException e) {
        if (!createParents) {
            throw e;
        }
        String parentDir = path.substring(0, path.lastIndexOf('/'));
        createPersistent(parentDir, createParents);
        return createPersistentSequential(path, createParents);
    }
}
 

public void close() {
  try {
    zkClient.close();
  } catch (ZkInterruptedException e) {
    LOG.warn("Interrupted when closing zkClient. Clearing the interrupted status and retrying.", e);
    Thread.interrupted();
    zkClient.close();
    Thread.currentThread().interrupt();
  }
}
 

public boolean waitForKeeperState(KeeperState keeperState, long time, TimeUnit timeUnit) throws ZkInterruptedException {
    if (_zookeeperEventThread != null && Thread.currentThread() == _zookeeperEventThread) {
        throw new IllegalArgumentException("Must not be done in the zookeeper event thread.");
    }
    Date timeout = new Date(System.currentTimeMillis() + timeUnit.toMillis(time));

    LOG.info("Waiting for keeper state " + keeperState);
    acquireEventLock();
    try {
        boolean stillWaiting = true;
        while (_currentState != keeperState) {
            if (!stillWaiting) {
                return false;
            }
            stillWaiting = getEventLock().getStateChangedCondition().awaitUntil(timeout);
            // Throw an exception in the case authorization fails
            if (_currentState == KeeperState.AuthFailed && _isZkSaslEnabled) {
                throw new ZkAuthFailedException("Authentication failure");
            }
        }
        LOG.debug("State is " + _currentState);
        return true;
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    } finally {
        getEventLock().unlock();
    }
}
 

/**
 * Create a persistent Sequential node.
 *
 * @param path
 * @param createParents if true all parent dirs are created as well and no
 *                      {@link ZkNodeExistsException} is thrown in case the path already exists
 * @throws ZkInterruptedException   if operation was interrupted, or a
 *                                  required reconnection got interrupted
 * @throws IllegalArgumentException if called parseFrom anything except the
 *                                  ZooKeeper event thread
 * @throws ZkException              if any ZooKeeper errors occurred
 * @throws RuntimeException         if any other errors occurs
 */
public String createPersistentSequential(String path, boolean createParents) throws ZkInterruptedException,
        IllegalArgumentException, ZkException,
        RuntimeException {
    try {
        return create(path, null, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (ZkNoNodeException e) {
        if (!createParents) {
            throw e;
        }
        String parentDir = path.substring(0, path.lastIndexOf('/'));
        createPersistent(parentDir, createParents);
        return createPersistentSequential(path, createParents);
    }
}
 

public void close() {
  try {
    if (zkUtils != null)
      zkUtils.close();
  } catch (ZkInterruptedException ex) {
    // Swallowing due to occurrence in the last stage of lifecycle(Not actionable).
    LOG.error("Exception in close(): ", ex);
  }
}
 

public void shutdown() {
    LOGGER.info("ParameterDynamicZookeeper Shutting Down");
    this.stopScheduled();
    try {
        this.zkClient.close();
    } catch (ZkInterruptedException e) {
        LOGGER.error("ParameterDynamicZookeeper Exception - Shutdown", e);
    }
    LOGGER.info("ParameterDynamicZookeeper Shutdown");
}
 

private void acquireEventLock() {
    try {
        getEventLock().lockInterruptibly();
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    }
}
 

/**
 * Create a persistent Sequential node.
 *
 * @param path
 * @param createParents if true all parent dirs are created as well and no
 * {@link ZkNodeExistsException} is thrown in case the path already exists
 * @throws ZkInterruptedException if operation was interrupted, or a
 * required reconnection got interrupted
 * @throws IllegalArgumentException if called from anything except the
 * ZooKeeper event thread
 * @throws ZkException if any ZooKeeper exception occurred
 * @throws RuntimeException if any other exception occurs
 */
public String createPersistentSequential(String path, boolean createParents) throws ZkInterruptedException,
                                                                            IllegalArgumentException, ZkException,
                                                                            RuntimeException {
    try {
        return create(path, null, CreateMode.PERSISTENT_SEQUENTIAL);
    } catch (ZkNoNodeException e) {
        if (!createParents) {
            throw e;
        }
        String parentDir = path.substring(0, path.lastIndexOf('/'));
        createPersistent(parentDir, createParents);
        return createPersistentSequential(path, createParents);
    }
}
 

@Test
public void testCloseShouldRetryOnceOnInterruptedException() {
  ZkClient zkClient = Mockito.mock(ZkClient.class);
  ZkUtils zkUtils = new ZkUtils(KEY_BUILDER, zkClient, CONNECTION_TIMEOUT_MS, SESSION_TIMEOUT_MS, new NoOpMetricsRegistry());

  Mockito.doThrow(new ZkInterruptedException(new InterruptedException()))
         .doAnswer(invocation -> null)
         .when(zkClient).close();

  zkUtils.close();

  Mockito.verify(zkClient, Mockito.times(2)).close();
}
 

public void shutdown() {
    LOGGER.info("ParameterDynamicZookeeper Shutting Down");
    this.stopScheduled();
    try {
        this.zkClient.close();
    } catch (ZkInterruptedException e) {
        LOGGER.error("ParameterDynamicZookeeper Exception - Shutdown", e);
    }
    LOGGER.info("ParameterDynamicZookeeper Shutdown");
}
 

private void reconnect() {
    getEventLock().lock();
    try {
        _connection.close();
        _connection.connect(this);
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    } finally {
        getEventLock().unlock();
    }
}
 

private void reconnect() {
    getEventLock().lock();
    try {
        _connection.close();
        _connection.connect(this);
    } catch (InterruptedException e) {
        throw new ZkInterruptedException(e);
    } finally {
        getEventLock().unlock();
    }
}