Java Stat类代码示例

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
/**
 * Create a new Stat, fill in dummy values trying to catch Assert.failure
 * to copy in client or server code.
 *
 * @return a new stat with dummy values
 */
private Stat newStat() {
    Stat stat = new Stat();

    stat.setAversion(100);
    stat.setCtime(100);
    stat.setCversion(100);
    stat.setCzxid(100);
    stat.setDataLength(100);
    stat.setEphemeralOwner(100);
    stat.setMtime(100);
    stat.setMzxid(100);
    stat.setNumChildren(100);
    stat.setPzxid(100);
    stat.setVersion(100);

    return stat;
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
private void connect(TxZookeeperConfig config) {
    try {
        zooKeeper = new ZooKeeper(config.getHost(), config.getSessionTimeOut(), watchedEvent -> {
            if (watchedEvent.getState() == Watcher.Event.KeeperState.SyncConnected) {
                // 放开闸门, wait在connect方法上的线程将被唤醒
                COUNT_DOWN_LATCH.countDown();
            }
        });
        COUNT_DOWN_LATCH.await();
        Stat stat = zooKeeper.exists(rootPath, false);
        if (stat == null) {
            zooKeeper.create(rootPath, rootPath.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    } catch (Exception e) {
        throw new TransactionIoException(e);
    }


}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
public void processResult(int rc, String path,
        Object ctx, byte[] data, Stat stat) {
    if (rc == KeeperException.Code.NONODE.intValue()) {
        // we can just ignore because the child watcher takes care of this
        return;
    }
    if (rc != KeeperException.Code.OK.intValue()) {
        zk.getData(myNode, (Watcher)ctx, this, ctx);
    }
    int currVer = stat.getVersion();
    if (currVer != lastVer) {
        String parts[] = new String(data).split(" ", 2);
        myInstance.configure(parts[1]);
        lastVer = currVer;
    }
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
@Test
public void testCreateEphemeralZNode() 
throws KeeperException, InterruptedException, IOException {
    ZSession session = createSession("30");
    
    WebResource wr = znodesr.path("/")
        .queryParam("op", "create")
        .queryParam("name", "ephemeral-test")
        .queryParam("ephemeral", "true")
        .queryParam("session", session.id)
        .queryParam("null", "true");
    
    Builder b = wr.accept(MediaType.APPLICATION_JSON);
    ClientResponse cr = b.post(ClientResponse.class);
    Assert.assertEquals(ClientResponse.Status.CREATED, cr.getClientResponseStatus());
    
    Stat stat = new Stat();
    zk.getData("/ephemeral-test", false, stat);
    
    ZooKeeper sessionZK = ZooKeeperService.getClient(CONTEXT_PATH, session.id);
    Assert.assertEquals(stat.getEphemeralOwner(), sessionZK.getSessionId());
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
public void testRoundTrip() throws IOException {
    MultiResponse response = new MultiResponse();

    response.add(new OpResult.CheckResult());
    response.add(new OpResult.CreateResult("foo-bar"));
    response.add(new OpResult.DeleteResult());

    Stat s = new Stat();
    s.setCzxid(546);
    response.add(new OpResult.SetDataResult(s));

    MultiResponse decodedResponse = codeDecode(response);

    Assert.assertEquals(response, decodedResponse);
    Assert.assertEquals(response.hashCode(), decodedResponse.hashCode());
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
/**
 * The asynchronous version of getACL.
 *
 * @see #getACL(String, Stat)
 */
public void getACL(final String path, Stat stat, ACLCallback cb,
        Object ctx)
{
    final String clientPath = path;
    PathUtils.validatePath(clientPath);

    final String serverPath = prependChroot(clientPath);

    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.getACL);
    GetACLRequest request = new GetACLRequest();
    request.setPath(serverPath);
    GetACLResponse response = new GetACLResponse();
    cnxn.queuePacket(h, new ReplyHeader(), request, response, cb,
            clientPath, serverPath, ctx, null);
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
public static void main(String[] args) {
    String connStr = "127.0.0.1:2181";
    try {
        ZooKeeper zookeeper = new ZooKeeper(connStr, 100000,
            new Watcher() {
                public void process(WatchedEvent event) {
                    logger.debug("监控被触发的事件");
                }
            });
        Stat stat = new Stat();
        byte[] result = zookeeper.getData("/saf_service/com.ipd.testjsf.HelloBaontService/providers", false, stat);
        zookeeper.setData("/saf_service/com.ipd.testjsf.HelloBaontService/providers", result, stat.getVersion());
        System.out.println(result);
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
/**
 * Creates the specified node with the specified data and watches it.
 *
 * <p>Throws an exception if the node already exists.
 *
 * <p>The node created is persistent and open access.
 *
 * <p>Returns the version number of the created node if successful.
 *
 * @param zkw zk reference
 * @param znode path of node to create
 * @param data data of node to create
 * @return version of node created
 * @throws KeeperException if unexpected zookeeper exception
 * @throws KeeperException.NodeExistsException if node already exists
 */
public static int createAndWatch(ZooKeeperWatcher zkw,
    String znode, byte [] data)
throws KeeperException, KeeperException.NodeExistsException {
  try {
    zkw.getRecoverableZooKeeper().create(znode, data, createACL(zkw, znode),
        CreateMode.PERSISTENT);
    Stat stat = zkw.getRecoverableZooKeeper().exists(znode, zkw);
    if (stat == null){
      // Likely a race condition. Someone deleted the znode.
      throw KeeperException.create(KeeperException.Code.SYSTEMERROR,
          "ZK.exists returned null (i.e.: znode does not exist) for znode=" + znode);
    }
   return stat.getVersion();
  } catch (InterruptedException e) {
    zkw.interruptedException(e);
    return -1;
  }
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
@Test(timeout = 60000)
public void testRootWatchTriggered() throws Exception {
    class MyWatcher implements Watcher{
        boolean fired=false;
        public void process(WatchedEvent event) {
            if(event.getPath().equals("/"))
                fired=true;
        }
    }
    MyWatcher watcher=new MyWatcher();
    // set a watch on the root node
    dt.getChildren("/", new Stat(), watcher);
    // add a new node, should trigger a watch
    dt.createNode("/xyz", new byte[0], null, 0, dt.getNode("/").stat.getCversion()+1, 1, 1);
    Assert.assertFalse("Root node watch not triggered",!watcher.fired);
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
public boolean deleteNode(String nodePath) {
    if (connected) {
        try {
            Stat s = zooKeeper.exists(nodePath, false);
            if (s != null) {
                List<String> children = zooKeeper.getChildren(nodePath,
                        false);
                for (String child : children) {
                    String node = nodePath + "/" + child;
                    deleteNode(node);
                }
                zooKeeper.delete(nodePath, -1);
            }
            return true;
        } catch (Exception e) {
            LoggerFactory.getLogger().error(
                    "Error occurred deleting node: " + nodePath, e);
        }
    }
    return false;
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
/**
 * verify that if create znode results in nodeexists and that znode is deleted
 * before exists() watch is set then the return of the exists() method results
 * in attempt to re-create the znode and become active
 */
@Test
public void testCreateNodeResultRetryNoNode() {
  elector.joinElection(data);

  elector.processResult(Code.CONNECTIONLOSS.intValue(), ZK_LOCK_NAME, mockZK,
      ZK_LOCK_NAME);
  elector.processResult(Code.CONNECTIONLOSS.intValue(), ZK_LOCK_NAME, mockZK,
      ZK_LOCK_NAME);
  elector.processResult(Code.NODEEXISTS.intValue(), ZK_LOCK_NAME, mockZK,
      ZK_LOCK_NAME);
  verifyExistCall(1);

  elector.processResult(Code.NONODE.intValue(), ZK_LOCK_NAME, mockZK,
      (Stat) null);
  Mockito.verify(mockApp, Mockito.times(1)).enterNeutralMode();
  Mockito.verify(mockZK, Mockito.times(4)).create(ZK_LOCK_NAME, data,
      Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL, elector, mockZK);
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
private void connect(TccZookeeperConfig config) {
    try {
        zooKeeper = new ZooKeeper(config.getHost(), config.getSessionTimeOut(), watchedEvent -> {
            if (watchedEvent.getState() == Watcher.Event.KeeperState.SyncConnected) {
                // 放开闸门, wait在connect方法上的线程将被唤醒
                LATCH.countDown();
            }
        });
        LATCH.await();
        Stat stat = zooKeeper.exists(rootPathPrefix, false);
        if (stat == null) {
            zooKeeper.create(rootPathPrefix, rootPathPrefix.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    } catch (Exception e) {
        throw new TccRuntimeException(e);
    }


}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
@Test
public void testDefaultConnection() throws Exception {
  // Default root from sabot-module.conf
  assertNull(zooKeeperServer.getZKClient().exists("/dremio/test-path", false));

  final SabotConfig config = DEFAULT_SABOT_CONFIG
      .withValue(ZK_ROOT, ConfigValueFactory.fromAnyRef("dremio/test-path"))
      .withValue(CLUSTER_ID, ConfigValueFactory.fromAnyRef("test-cluster-id"));

  try(ZKClusterClient client = new ZKClusterClient(config, new Provider<Integer>() {
    @Override
    public Integer get() {
      return zooKeeperServer.getPort();
    }
  })) {
    client.start();
    ZKServiceSet serviceSet = client.newServiceSet("coordinator");
    serviceSet.register(NodeEndpoint.newBuilder().setAddress("foo").build());


    Stat stat = zooKeeperServer.getZKClient().exists("/dremio/test-path/test-cluster-id/coordinator", false);
    assertNotNull(stat);
    assertEquals(1, stat.getNumChildren());
  }
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
/**
 * Gets the status of a node in ZooKeeper
 *
 * @param p_path
 *     the node path
 * @param p_watcher
 *     the watcher
 * @return true if the node exists, fals eotherwise
 * @throws ZooKeeperException
 *     if ZooKeeper could not accessed
 */
public Stat getStatus(final String p_path, final Watcher p_watcher) throws ZooKeeperException {
    Stat ret;

    assert p_path != null;

    try {
        if (m_zookeeper == null) {
            connect();
        }

        if (!p_path.isEmpty()) {
            ret = m_zookeeper.exists(m_path + '/' + p_path, p_watcher);
        } else {
            ret = m_zookeeper.exists(m_path, p_watcher);
        }
    } catch (final KeeperException | InterruptedException e) {
        throw new ZooKeeperException("Could not access ZooKeeper", e);
    }

    return ret;
}
 

import org.apache.zookeeper.data.Stat; //导入依赖的package包/类
@Test
public void testCreateEphemeralZNode() 
throws KeeperException, InterruptedException, IOException {
    ZSession session = createSession("30");
    
    WebResource wr = znodesr.path("/")
        .queryParam("op", "create")
        .queryParam("name", "ephemeral-test")
        .queryParam("ephemeral", "true")
        .queryParam("session", session.id)
        .queryParam("null", "true");
    
    Builder b = wr.accept(MediaType.APPLICATION_JSON);
    ClientResponse cr = b.post(ClientResponse.class);
    assertEquals(ClientResponse.Status.CREATED, cr.getClientResponseStatus());
    
    Stat stat = new Stat();
    zk.getData("/ephemeral-test", false, stat);
    
    ZooKeeper sessionZK = ZooKeeperService.getClient(CONTEXT_PATH, session.id);
    assertEquals(stat.getEphemeralOwner(), sessionZK.getSessionId());
}