Java ZooKeeper.getState方法代码示例

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
private void waitForAll(ZooKeeper[] zks, States state) throws InterruptedException {
	int iterations = 10;
	boolean someoneNotConnected = true;
       while(someoneNotConnected) {
       	if (iterations-- == 0) {
       		ClientBase.logAllStackTraces();
		throw new RuntimeException("Waiting too long");
       	}
       	
       	someoneNotConnected = false;
       	for(ZooKeeper zk: zks) {
       		if (zk.getState() != state) {
       			someoneNotConnected = true;
       		}
       	}
       	Thread.sleep(1000);
       }
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
private void waitForAll(ZooKeeper[] zks, States state) throws InterruptedException {
    int iterations = ClientBase.CONNECTION_TIMEOUT / 1000;
    boolean someoneNotConnected = true;
    while (someoneNotConnected) {
        if (iterations-- == 0) {
            ClientBase.logAllStackTraces();
            throw new RuntimeException("Waiting too long");
        }

        someoneNotConnected = false;
        for (ZooKeeper zk : zks) {
            if (zk.getState() != state) {
                someoneNotConnected = true;
                break;
            }
        }
        Thread.sleep(1000);
    }
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
@Test
public void testClientRetry() throws IOException, InterruptedException, TimeoutException{
    CountdownWatcher cdw1 = new CountdownWatcher();
    CountdownWatcher cdw2 = new CountdownWatcher();
    ZooKeeper zk = new ZooKeeper(hostPort, 10000, cdw1);
    try {
        cdw1.waitForConnected(CONNECTION_TIMEOUT);
        ZooKeeper zk2 = new ZooKeeper(hostPort, 10000, cdw2);
        try {
            States s1 = zk.getState();
            States s2 = zk2.getState();
            Assert.assertSame(s1,States.CONNECTED);
            Assert.assertSame(s2,States.CONNECTING);
            cdw1.reset();
            zk.close();
            cdw1.waitForDisconnected(CONNECTION_TIMEOUT);
            cdw2.waitForConnected(CONNECTION_TIMEOUT);
            Assert.assertSame(zk2.getState(),States.CONNECTED);
        } finally {
            zk2.close();
        }
    } finally {
        zk.close();
    }
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
@Test
public void testClientRetry() throws IOException, InterruptedException, TimeoutException{
    CountdownWatcher cdw1 = new CountdownWatcher();
    CountdownWatcher cdw2 = new CountdownWatcher();
    ZooKeeper zk = new ZooKeeper(hostPort, 10000, cdw1);
    try {
        cdw1.waitForConnected(CONNECTION_TIMEOUT);
        ZooKeeper zk2 = new ZooKeeper(hostPort, 10000, cdw2);
        try {
            States s1 = zk.getState();
            States s2 = zk2.getState();
            Assert.assertSame(s1,States.CONNECTED);
            Assert.assertSame(s2,States.CONNECTING);
            cdw1.reset();
            cdw1.waitForDisconnected(CONNECTION_TIMEOUT);
            cdw2.waitForConnected(CONNECTION_TIMEOUT);
            Assert.assertSame(zk2.getState(),States.CONNECTED);
        } finally {
            zk2.close();
        }
    } finally {
        zk.close();
    }
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
public LogManagerFactoryImpl(ClientConfiguration clientConfiguration, BookKeeperConfig config)
	throws Exception {
	bookKeeperConfig = config;
	checkNotNull(clientConfiguration);
	String servers = clientConfiguration.getZkServers();
	checkNotNull(servers);
	final CountDownLatch countDownLatch = new CountDownLatch(1);

	zooKeeper = new ZooKeeper(servers, clientConfiguration.getZkTimeout(), event -> {
		if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
			logger.info("Connected to zookeeper ,connectString = {}", servers);
			countDownLatch.countDown();
		} else {
			logger.error("Failed to connect zookeeper,connectString = {}", servers);
		}
	});
	if (!countDownLatch.await(clientConfiguration.getZkTimeout(), TimeUnit.MILLISECONDS)
		|| zooKeeper.getState() != ZooKeeper.States.CONNECTED) {
		throw new LedgerStorageException(
			"Error connecting to zookeeper server ,connectString = " + servers + ".");
	}

	this.bookKeeper = new BookKeeper(clientConfiguration, zooKeeper);
	RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
	CuratorFramework curatorFramework = CuratorFrameworkFactory.newClient(servers, retryPolicy);
	curatorFramework.start();
	asyncCuratorFramework = AsyncCuratorFramework.wrap(curatorFramework);
	logInfoStorage = new LogInfoStorageImpl(asyncCuratorFramework);
	offsetStorage = new ZkOffsetStorageImpl(logInfoStorage, asyncCuratorFramework);
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
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;
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
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;
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
private void waitForOne(ZooKeeper zk, States state) throws InterruptedException {
    int iterations = ClientBase.CONNECTION_TIMEOUT / 500;
    while (zk.getState() != state) {
        if (iterations-- == 0) {
            throw new RuntimeException("Waiting too long");
        }
        Thread.sleep(500);
    }
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
public static void waitUntilConnected(ZooKeeper zooKeeper) {
    CountDownLatch connectedLatch = new CountDownLatch(1);
    Watcher watcher = new ConnectedWatcher(connectedLatch);
    zooKeeper.register(watcher);
    if (States.CONNECTING == zooKeeper.getState()) {
        try {
            connectedLatch.await();
        } catch (InterruptedException e) {
            throw new IllegalStateException(e);
        }
    }
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
private void waitForOne(ZooKeeper zk, States state) throws InterruptedException {
	while(zk.getState() != state) {
		Thread.sleep(500);
	}
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
/**
 * Ensures that upon connection to a read-only server client receives
 * ConnectedReadOnly state notification.
 */
@Test(timeout = 90000)
public void testConnectionEvents() throws Exception {
    final List<KeeperState> states = new ArrayList<KeeperState>();
    ZooKeeper zk = new ZooKeeper(qu.getConnString(), CONNECTION_TIMEOUT,
            new Watcher() {
                public void process(WatchedEvent event) {
                    states.add(event.getState());
                }
            }, true);
    boolean success = false;
    for (int i = 0; i < 30; i++) {
        try {
            zk.create("/test", "test".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
                    CreateMode.PERSISTENT);
            success=true;
            break;
        } catch(KeeperException.ConnectionLossException e) {
            Thread.sleep(1000);               
        }            
    }
    Assert.assertTrue("Did not succeed in connecting in 30s", success);

    // kill peer and wait no more than 5 seconds for read-only server
    // to be started (which should take one tickTime (2 seconds))
    qu.shutdown(2);
    long start = System.currentTimeMillis();
    while (!(zk.getState() == States.CONNECTEDREADONLY)) {
        Thread.sleep(200);
        // FIXME this was originally 5 seconds, but realistically, on random/slow/virt hosts, there is no way to guarantee this
        Assert.assertTrue("Can't connect to the server", System
                .currentTimeMillis()
                - start < 30000);
    }

    // At this point states list should contain, in the given order,
    // SyncConnected, Disconnected, and ConnectedReadOnly states
    Assert.assertTrue("ConnectedReadOnly event wasn't received", states
            .get(2) == KeeperState.ConnectedReadOnly);
    zk.close();
}
 

import org.apache.zookeeper.ZooKeeper; //导入方法依赖的package包/类
/**
 * 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();
  }
}