Github user karanmehta93 commented on a diff in the pull request:

    https://github.com/apache/zookeeper/pull/307#discussion_r128122188
  
    --- Diff: 
src/java/test/org/apache/zookeeper/server/ZooKeeperServerMainTest.java ---
    @@ -138,14 +145,56 @@ void delete(File f) throws IOException {
             ServerCnxnFactory getCnxnFactory() {
                 return main.getCnxnFactory();
             }
    +
         }
     
    -    public static  class TestZKSMain extends ZooKeeperServerMain {
    +    public static class TestZKSMain extends ZooKeeperServerMain {
    +
    +        private ServerStats serverStats;
    +
    +        @Override
    +        public ZooKeeperServer getZooKeeperServer(FileTxnSnapLog txnLog, 
ServerConfig config, ZKDatabase zkDb) {
    +            ZooKeeperServer zooKeeperServer = 
super.getZooKeeperServer(txnLog, config, zkDb);
    +            serverStats = zooKeeperServer.serverStats();
    +            return zooKeeperServer;
    +        }
    +
    +        @Override
             public void shutdown() {
                 super.shutdown();
             }
         }
     
    +    // Test for ZOOKEEPER-2770 ZooKeeper slow operation log
    +    @Test
    +    public void testRequestWarningThreshold() throws IOException, 
KeeperException, InterruptedException {
    +        ClientBase.setupTestEnv();
    +
    +        final int CLIENT_PORT = PortAssignment.unique();
    +
    +        MainThread main = new MainThread(CLIENT_PORT, true, null, 0);
    +        main.start();
    +
    +        Assert.assertTrue("waiting for server being up",
    +                ClientBase.waitForServerUp("127.0.0.1:" + CLIENT_PORT,
    +                        CONNECTION_TIMEOUT));
    +        // Get the stats object from the ZooKeeperServer to keep track of 
high latency requests.
    +        ServerStats stats = main.main.serverStats;
    +
    +        ZooKeeper zk = new ZooKeeper("127.0.0.1:" + CLIENT_PORT,
    +                ClientBase.CONNECTION_TIMEOUT, this);
    +
    +        zk.create("/foo1", "foobar".getBytes(), Ids.OPEN_ACL_UNSAFE,
    +                CreateMode.PERSISTENT);
    +
    +        Assert.assertEquals(new String(zk.getData("/foo1", null, null)), 
"foobar");
    +        // It takes a while for the counter to get updated sometimes, this 
is added to reduce flakyness
    +        Thread.sleep(1000);
    --- End diff --
    
    @tdunning 
    
    > OK. The point of the timeout, however, is that an update has not been 
applied. The sync() is designed to wait for exactly this.
    
    Where does the update have to applied? To ZKDb or the counter? This is what 
my understanding is, correct me where I am getting it wrong. The call to 
`zk.getData()` is a blocking call. The `FinalRequestProcessor` completes all 
the relevant task related to this request and in the end sends out a reply 
packet to the client. It puts the packet on a queue which is handled by the 
`ServerCnxn` on a separate thread. In the meanwhile, the former thread goes and 
increments the `numRequestsAboveThresholdTime` counter. In a case when client 
gets acknowledged about the data being persisted at the node, the test proceeds 
to check the counter value. If the later thread got suspended due to any reason 
and didn't update the counter, this might cause the test the fail.
    
    > Code that depends on timeouts is not deterministic in my book. It may 
just have a low probability of failure.
    
    Agreed, using the term `completely deterministic` on my part was incorrect.



---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastruct...@apache.org or file a JIRA ticket
with INFRA.
---

Reply via email to