accumulo-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bhava...@apache.org
Subject [2/3] git commit: ACCUMULO-2865 Add ZooCacheTest
Date Fri, 06 Jun 2014 20:12:28 GMT
ACCUMULO-2865 Add ZooCacheTest

This adds a unit test for ZooCache. ZooCache itself was only changed slightly, with the
addition of methods to check if information was cached and improvements to its comments.


Project: http://git-wip-us.apache.org/repos/asf/accumulo/repo
Commit: http://git-wip-us.apache.org/repos/asf/accumulo/commit/4950870d
Tree: http://git-wip-us.apache.org/repos/asf/accumulo/tree/4950870d
Diff: http://git-wip-us.apache.org/repos/asf/accumulo/diff/4950870d

Branch: refs/heads/master
Commit: 4950870de6dcf26dc1aa78f63e39da513a0d92de
Parents: 18d6ca1
Author: Bill Havanki <bhavanki@cloudera.com>
Authored: Fri Jun 6 12:33:21 2014 -0400
Committer: Bill Havanki <bhavanki@cloudera.com>
Committed: Fri Jun 6 14:13:50 2014 -0400

----------------------------------------------------------------------
 .../accumulo/fate/zookeeper/ZooCache.java       |  85 ++++-
 .../accumulo/fate/zookeeper/ZooCacheTest.java   | 345 +++++++++++++++++++
 2 files changed, 423 insertions(+), 7 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/accumulo/blob/4950870d/fate/src/main/java/org/apache/accumulo/fate/zookeeper/ZooCache.java
----------------------------------------------------------------------
diff --git a/fate/src/main/java/org/apache/accumulo/fate/zookeeper/ZooCache.java b/fate/src/main/java/org/apache/accumulo/fate/zookeeper/ZooCache.java
index 99ffd04..d9eb243 100644
--- a/fate/src/main/java/org/apache/accumulo/fate/zookeeper/ZooCache.java
+++ b/fate/src/main/java/org/apache/accumulo/fate/zookeeper/ZooCache.java
@@ -16,6 +16,7 @@
  */
 package org.apache.accumulo.fate.zookeeper;
 
+import com.google.common.annotations.VisibleForTesting;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
@@ -27,7 +28,6 @@ import java.util.ConcurrentModificationException;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 
 import org.apache.log4j.Logger;
 import org.apache.zookeeper.KeeperException;
@@ -38,8 +38,8 @@ import org.apache.zookeeper.ZooKeeper;
 import org.apache.zookeeper.data.Stat;
 
 /**
- * Caches values stored in zookeeper and keeps them up to date as they change in zookeeper.
- * 
+ * A cache for values stored in ZooKeeper. Values are kept up to date as they
+ * change.
  */
 public class ZooCache {
   private static final Logger log = Logger.getLogger(ZooCache.class);
@@ -100,14 +100,35 @@ public class ZooCache {
     }
   }
 
+  /**
+   * Creates a new cache.
+   *
+   * @param zooKeepers comma-separated list of ZooKeeper host[:port]s
+   * @param sessionTimeout ZooKeeper session timeout
+   */
   public ZooCache(String zooKeepers, int sessionTimeout) {
     this(zooKeepers, sessionTimeout, null);
   }
 
+  /**
+   * Creates a new cache. The given watcher is called whenever a watched node
+   * changes.
+   *
+   * @param zooKeepers comma-separated list of ZooKeeper host[:port]s
+   * @param sessionTimeout ZooKeeper session timeout
+   * @param watcher watcher object
+   */
   public ZooCache(String zooKeepers, int sessionTimeout, Watcher watcher) {
     this(new ZooReader(zooKeepers, sessionTimeout), watcher);
   }
 
+  /**
+   * Creates a new cache. The given watcher is called whenever a watched node
+   * changes.
+   *
+   * @param reader ZooKeeper reader
+   * @param watcher watcher object
+   */
   public ZooCache(ZooReader reader, Watcher watcher) {
     this.zReader = reader;
     this.cache = new HashMap<String,byte[]>();
@@ -134,7 +155,7 @@ public class ZooCache {
 
       } catch (KeeperException e) {
         if (e.code() == Code.NONODE) {
-          log.error("Looked up non existant node in cache " + e.getPath(), e);
+          log.error("Looked up non-existent node in cache " + e.getPath(), e);
         }
         log.warn("Zookeeper error, will retry", e);
       } catch (InterruptedException e) {
@@ -155,6 +176,12 @@ public class ZooCache {
     }
   }
 
+  /**
+   * Gets the children of the given node. A watch is established by this call.
+   *
+   * @param zPath path of node
+   * @return children list, or null if node has no children or does not exist
+   */
   public synchronized List<String> getChildren(final String zPath) {
 
     ZooRunnable zr = new ZooRunnable() {
@@ -186,10 +213,25 @@ public class ZooCache {
     return Collections.unmodifiableList(children);
   }
 
+  /**
+   * Gets data at the given path. Status information is not returned. A watch is
+   * established by this call.
+   *
+   * @param zPath path to get
+   * @return path data, or null if non-existent
+   */
   public synchronized byte[] get(final String zPath) {
     return get(zPath, null);
   }
 
+  /**
+   * Gets data at the given path, filling status information into the given
+   * <code>Stat</code> object. A watch is established by this call.
+   *
+   * @param zPath path to get
+   * @param stat status object to populate
+   * @return path data, or null if non-existent
+   */
   public synchronized byte[] get(final String zPath, Stat stat) {
     ZooRunnable zr = new ZooRunnable() {
 
@@ -200,11 +242,11 @@ public class ZooCache {
           return;
 
         /*
-         * The following call to exists() is important, since we are caching that a node
does not exist. Once the node comes into existance, it will be added to
-         * the cache. But this notification of a node coming into existance will only be
given if exists() was previously called.
+         * The following call to exists() is important, since we are caching that a node
does not exist. Once the node comes into existence, it will be added to
+         * the cache. But this notification of a node coming into existence will only be
given if exists() was previously called.
          * 
          * If the call to exists() is bypassed and only getData() is called with a special
case that looks for Code.NONODE in the KeeperException, then
-         * non-existance can not be cached.
+         * non-existence can not be cached.
          */
 
         Stat stat = zooKeeper.exists(zPath, watcher);
@@ -270,12 +312,41 @@ public class ZooCache {
     statCache.remove(zPath);
   }
 
+  /**
+   * Clears this cache.
+   */
   public synchronized void clear() {
     cache.clear();
     childrenCache.clear();
     statCache.clear();
   }
 
+  /**
+   * Checks if a data value (or lack of one) is cached.
+   *
+   * @param zPath path of node
+   * @return true if data value is cached
+   */
+  @VisibleForTesting
+  synchronized boolean dataCached(String zPath) {
+    return cache.containsKey(zPath);
+  }
+  /**
+   * Checks if children of a node (or lack of them) are cached.
+   *
+   * @param zPath path of node
+   * @return true if children are cached
+   */
+  @VisibleForTesting
+  synchronized boolean childrenCached(String zPath) {
+    return childrenCache.containsKey(zPath);
+  }
+
+  /**
+   * Clears this cache of all information about nodes rooted at the given path.
+   *
+   * @param zPath path of top node
+   */
   public synchronized void clear(String zPath) {
 
     for (Iterator<String> i = cache.keySet().iterator(); i.hasNext();) {

http://git-wip-us.apache.org/repos/asf/accumulo/blob/4950870d/fate/src/test/java/org/apache/accumulo/fate/zookeeper/ZooCacheTest.java
----------------------------------------------------------------------
diff --git a/fate/src/test/java/org/apache/accumulo/fate/zookeeper/ZooCacheTest.java b/fate/src/test/java/org/apache/accumulo/fate/zookeeper/ZooCacheTest.java
new file mode 100644
index 0000000..e3db785
--- /dev/null
+++ b/fate/src/test/java/org/apache/accumulo/fate/zookeeper/ZooCacheTest.java
@@ -0,0 +1,345 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.accumulo.fate.zookeeper;
+
+import java.util.List;
+import org.apache.zookeeper.KeeperException;
+import org.apache.zookeeper.WatchedEvent;
+import org.apache.zookeeper.Watcher;
+import org.apache.zookeeper.ZooKeeper;
+import org.apache.zookeeper.data.Stat;
+
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import org.easymock.Capture;
+import static org.easymock.EasyMock.anyObject;
+import static org.easymock.EasyMock.capture;
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.createStrictMock;
+import static org.easymock.EasyMock.eq;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.expectLastCall;
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.verify;
+
+public class ZooCacheTest {
+  private static final String ZPATH = "/some/path/in/zk";
+  private static final byte[] DATA = {(byte) 1, (byte) 2, (byte) 3, (byte) 4};
+  private static final List<String> CHILDREN = java.util.Arrays.asList(new String[]
{"huey", "dewey", "louie"});
+
+  private ZooReader zr;
+  private ZooKeeper zk;
+  private ZooCache zc;
+
+  @Before
+  public void setUp() throws Exception {
+    zr = createMock(ZooReader.class);
+    zk = createStrictMock(ZooKeeper.class);
+    expect(zr.getZooKeeper()).andReturn(zk);
+    expectLastCall().anyTimes();
+    replay(zr);
+
+    zc = new ZooCache(zr, null);
+  }
+
+  @Test
+  public void testGet() throws Exception {
+    testGet(false);
+  }
+
+  @Test
+  public void testGet_FillStat() throws Exception {
+    testGet(true);
+  }
+
+  private void testGet(boolean fillStat) throws Exception {
+    Stat myStat = null;
+    if (fillStat) {
+      myStat = new Stat();
+    }
+    long now = System.currentTimeMillis();
+    Stat existsStat = new Stat();
+    existsStat.setMtime(now);
+    expect(zk.exists(eq(ZPATH), anyObject(Watcher.class))).andReturn(existsStat);
+    expect(zk.getData(eq(ZPATH), anyObject(Watcher.class), eq(existsStat))).andReturn(DATA);
+    replay(zk);
+
+    assertFalse(zc.dataCached(ZPATH));
+    assertArrayEquals(DATA, (fillStat ? zc.get(ZPATH, myStat) : zc.get(ZPATH)));
+    verify(zk);
+    if (fillStat) {
+      assertEquals(now, myStat.getMtime());
+    }
+
+    assertTrue(zc.dataCached(ZPATH));
+    assertSame(DATA, zc.get(ZPATH)); // cache hit
+  }
+
+  @Test
+  public void testGet_NonExistent() throws Exception {
+    expect(zk.exists(eq(ZPATH), anyObject(Watcher.class))).andReturn(null);
+    replay(zk);
+
+    assertNull(zc.get(ZPATH));
+    verify(zk);
+  }
+
+  @Test
+  public void testGet_Retry_NoNode() throws Exception {
+    testGet_Retry(new KeeperException.NoNodeException(ZPATH));
+  }
+
+  @Test
+  public void testGet_Retry_ConnectionLoss() throws Exception {
+    testGet_Retry(new KeeperException.ConnectionLossException());
+  }
+
+  @Test
+  public void testGet_Retry_BadVersion() throws Exception {
+    testGet_Retry(new KeeperException.BadVersionException(ZPATH));
+  }
+
+  @Test
+  public void testGet_Retry_Interrupted() throws Exception {
+    testGet_Retry(new InterruptedException());
+  }
+
+  private void testGet_Retry(Exception e) throws Exception {
+    expect(zk.exists(eq(ZPATH), anyObject(Watcher.class))).andThrow(e);
+    Stat existsStat = new Stat();
+    expect(zk.exists(eq(ZPATH), anyObject(Watcher.class))).andReturn(existsStat);
+    expect(zk.getData(eq(ZPATH), anyObject(Watcher.class), eq(existsStat))).andReturn(DATA);
+    replay(zk);
+
+    assertArrayEquals(DATA, zc.get(ZPATH));
+    verify(zk);
+  }
+
+  @Test
+  public void testGet_Retry2_NoNode() throws Exception {
+    testGet_Retry2(new KeeperException.NoNodeException(ZPATH));
+  }
+
+  @Test
+  public void testGet_Retry2_ConnectionLoss() throws Exception {
+    testGet_Retry2(new KeeperException.ConnectionLossException());
+  }
+
+  @Test
+  public void testGet_Retry2_BadVersion() throws Exception {
+    testGet_Retry2(new KeeperException.BadVersionException(ZPATH));
+  }
+
+  @Test
+  public void testGet_Retry2_Interrupted() throws Exception {
+    testGet_Retry2(new InterruptedException());
+  }
+
+  private void testGet_Retry2(Exception e) throws Exception {
+    Stat existsStat = new Stat();
+    expect(zk.exists(eq(ZPATH), anyObject(Watcher.class))).andReturn(existsStat);
+    expect(zk.getData(eq(ZPATH), anyObject(Watcher.class), eq(existsStat))).andThrow(e);
+    expect(zk.exists(eq(ZPATH), anyObject(Watcher.class))).andReturn(existsStat);
+    expect(zk.getData(eq(ZPATH), anyObject(Watcher.class), eq(existsStat))).andReturn(DATA);
+    replay(zk);
+
+    assertArrayEquals(DATA, zc.get(ZPATH));
+    verify(zk);
+  }
+
+  // ---
+
+  @Test
+  public void testGetChildren() throws Exception {
+    expect(zk.getChildren(eq(ZPATH), anyObject(Watcher.class))).andReturn(CHILDREN);
+    replay(zk);
+
+    assertFalse(zc.childrenCached(ZPATH));
+    assertEquals(CHILDREN, zc.getChildren(ZPATH));
+    verify(zk);
+
+    assertTrue(zc.childrenCached(ZPATH));
+    // cannot check for sameness, return value is wrapped each time
+    assertEquals(CHILDREN, zc.getChildren(ZPATH)); // cache hit
+  }
+
+  @Test
+  public void testGetChildren_NoKids() throws Exception {
+    expect(zk.getChildren(eq(ZPATH), anyObject(Watcher.class))).andReturn(null);
+    replay(zk);
+
+    assertNull(zc.getChildren(ZPATH));
+    verify(zk);
+
+    assertNull(zc.getChildren(ZPATH)); // cache hit
+  }
+
+  @Test
+  public void testGetChildren_Retry() throws Exception {
+    expect(zk.getChildren(eq(ZPATH), anyObject(Watcher.class))).andThrow(new KeeperException.BadVersionException(ZPATH));
+    expect(zk.getChildren(eq(ZPATH), anyObject(Watcher.class))).andReturn(CHILDREN);
+    replay(zk);
+
+    assertEquals(CHILDREN, zc.getChildren(ZPATH));
+    verify(zk);
+  }
+
+  @Test
+  public void testGetChildren_EatNoNode() throws Exception {
+    expect(zk.getChildren(eq(ZPATH), anyObject(Watcher.class))).andThrow(new KeeperException.NoNodeException(ZPATH));
+    replay(zk);
+
+    assertNull(zc.getChildren(ZPATH));
+    verify(zk);
+  }
+
+  private static class TestWatcher implements Watcher {
+    private final WatchedEvent expectedEvent;
+    private boolean wasCalled;
+
+    TestWatcher(WatchedEvent event) {
+      expectedEvent = event;
+      wasCalled = false;
+    }
+
+    @Override
+    public void process(WatchedEvent event) {
+      assertSame(expectedEvent, event);
+      wasCalled = true;
+    }
+
+    boolean wasCalled() {
+      return wasCalled;
+    }
+  }
+
+  @Test
+  public void testWatchDataNode_Deleted() throws Exception {
+    testWatchDataNode(DATA, Watcher.Event.EventType.NodeDeleted, false);
+  }
+
+  @Test
+  public void testWatchDataNode_DataChanged() throws Exception {
+    testWatchDataNode(DATA, Watcher.Event.EventType.NodeDataChanged, false);
+  }
+
+  @Test
+  public void testWatchDataNode_Created() throws Exception {
+    testWatchDataNode(null, Watcher.Event.EventType.NodeCreated, false);
+  }
+
+  @Test
+  public void testWatchDataNode_NoneSyncConnected() throws Exception {
+    testWatchDataNode(null, Watcher.Event.EventType.None, true);
+  }
+
+  private void testWatchDataNode(byte[] initialData, Watcher.Event.EventType eventType, boolean
stillCached) throws Exception {
+    WatchedEvent event = new WatchedEvent(eventType, Watcher.Event.KeeperState.SyncConnected,
ZPATH);
+    TestWatcher exw = new TestWatcher(event);
+    zc = new ZooCache(zr, exw);
+
+    Watcher w = watchData(initialData);
+    w.process(event);
+    assertTrue(exw.wasCalled());
+    assertEquals(stillCached, zc.dataCached(ZPATH));
+  }
+
+  private Watcher watchData(byte[] initialData) throws Exception {
+    Capture<Watcher> cw = new Capture<Watcher>();
+    Stat existsStat = new Stat();
+    if (initialData != null) {
+      expect(zk.exists(eq(ZPATH), capture(cw))).andReturn(existsStat);
+      expect(zk.getData(eq(ZPATH), anyObject(Watcher.class), eq(existsStat))).andReturn(initialData);
+    } else {
+      expect(zk.exists(eq(ZPATH), capture(cw))).andReturn(null);
+    }
+    replay(zk);
+    zc.get(ZPATH);
+    assertTrue(zc.dataCached(ZPATH));
+
+    return cw.getValue();
+  }
+
+  @Test
+  public void testWatchDataNode_Disconnected() throws Exception {
+    testWatchDataNode_Clear(Watcher.Event.KeeperState.Disconnected);
+  }
+
+  @Test
+  public void testWatchDataNode_Expired() throws Exception {
+    testWatchDataNode_Clear(Watcher.Event.KeeperState.Expired);
+  }
+
+  private void testWatchDataNode_Clear(Watcher.Event.KeeperState state) throws Exception
{
+    WatchedEvent event = new WatchedEvent(Watcher.Event.EventType.None, state, null);
+    TestWatcher exw = new TestWatcher(event);
+    zc = new ZooCache(zr, exw);
+
+    Watcher w = watchData(DATA);
+    assertTrue(zc.dataCached(ZPATH));
+    w.process(event);
+    assertTrue(exw.wasCalled());
+    assertFalse(zc.dataCached(ZPATH));
+  }
+
+  @Test
+  public void testWatchChildrenNode_Deleted() throws Exception {
+    testWatchChildrenNode(CHILDREN, Watcher.Event.EventType.NodeDeleted, false);
+  }
+
+  @Test
+  public void testWatchChildrenNode_ChildrenChanged() throws Exception {
+    testWatchChildrenNode(CHILDREN, Watcher.Event.EventType.NodeChildrenChanged, false);
+  }
+
+  @Test
+  public void testWatchChildrenNode_Created() throws Exception {
+    testWatchChildrenNode(null, Watcher.Event.EventType.NodeCreated, false);
+  }
+
+  @Test
+  public void testWatchChildrenNode_NoneSyncConnected() throws Exception {
+    testWatchChildrenNode(CHILDREN, Watcher.Event.EventType.None, true);
+  }
+
+  private void testWatchChildrenNode(List<String> initialChildren, Watcher.Event.EventType
eventType, boolean stillCached) throws Exception {
+    WatchedEvent event = new WatchedEvent(eventType, Watcher.Event.KeeperState.SyncConnected,
ZPATH);
+    TestWatcher exw = new TestWatcher(event);
+    zc = new ZooCache(zr, exw);
+
+    Watcher w = watchChildren(initialChildren);
+    w.process(event);
+    assertTrue(exw.wasCalled());
+    assertEquals(stillCached, zc.childrenCached(ZPATH));
+  }
+
+  private Watcher watchChildren(List<String> initialChildren) throws Exception {
+    Capture<Watcher> cw = new Capture<Watcher>();
+    expect(zk.getChildren(eq(ZPATH), capture(cw))).andReturn(initialChildren);
+    replay(zk);
+    zc.getChildren(ZPATH);
+    assertTrue(zc.childrenCached(ZPATH));
+
+    return cw.getValue();
+  }
+}


Mime
View raw message