public ServerManager(WmsMaster wmsMaster) throws Exception {
try {
this.wmsMaster = wmsMaster;
this.conf = wmsMaster.getConfiguration();
this.zkc = wmsMaster.getZkClient();
this.ia = wmsMaster.getInetAddress();
this.startupTimestamp = wmsMaster.getStartTime();
this.metrics = wmsMaster.getMetrics();
maxRestartAttempts =
conf.getInt(
Constants.WMS_MASTER_SERVER_RESTART_HANDLER_ATTEMPTS,
Constants.DEFAULT_WMS_MASTER_SERVER_RESTART_HANDLER_ATTEMPTS);
retryIntervalMillis =
conf.getInt(
Constants.WMS_MASTER_SERVER_RESTART_HANDLER_RETRY_INTERVAL_MILLIS,
Constants.DEFAULT_WMS_MASTER_SERVER_RESTART_HANDLER_RETRY_INTERVAL_MILLIS);
retryCounterFactory = new RetryCounterFactory(maxRestartAttempts, retryIntervalMillis);
parentZnode =
conf.get(Constants.ZOOKEEPER_ZNODE_PARENT, Constants.DEFAULT_ZOOKEEPER_ZNODE_PARENT);
pool = Executors.newSingleThreadExecutor();
} catch (Exception e) {
e.printStackTrace();
LOG.error(e);
throw e;
}
}
@Test(timeout = 20000l)
@Ignore
public void testLockWorksUnderContentionDifferentClients() throws Exception {
int numThreads = 5;
final int numIterations = 100;
ExecutorService service = Executors.newFixedThreadPool(numThreads);
final CyclicBarrier startBarrier = new CyclicBarrier(numThreads + 1);
final CyclicBarrier endBarrier = new CyclicBarrier(numThreads + 1);
final UnsafeOperator operator = new UnsafeOperator();
for (int i = 0; i < numThreads; i++) {
service.submit(
new Callable<Void>() {
@Override
public Void call() throws Exception {
startBarrier.await(); // make sure all threads are in the same place before starting
// create the lock that we're going to use
ZooKeeper newZk = newZooKeeper();
try {
Lock testLock = new ReentrantZkLock(baseLockPath, new BaseZkSessionManager(newZk));
for (int j = 0; j < numIterations; j++) {
testLock.lock();
try {
operator.increment();
} finally {
testLock.unlock();
}
}
} finally {
closeZooKeeper(newZk);
}
// enter the end barrier to ensure that things are finished
endBarrier.await();
return null;
}
});
}
// start the test
startBarrier.await();
// wait for the end of the test
endBarrier.await();
// check that the number of operations that actually were recorded are correct
int correctOps = numIterations * numThreads;
assertEquals("Number of Operations recorded was incorrect!", correctOps, operator.getValue());
}
/**
* Unit tests for ReentrantZkLock
*
* <p>Note: These methods will not run without first having a ZooKeeper server started on {@code
* hostString}.
*
* @author Scott Fines
* @version 1.0 Date: 21-Nov-2010 Time: 13:49:20
*/
@Ignore("Ignoring until rewrite")
public class ReentrantZkLockTest {
private static final String hostString = "localhost:2181";
private static final String baseLockPath = "/test-locks";
private static final int timeout = 2000;
private static final ExecutorService testService =
Executors.newFixedThreadPool(2, new TestingThreadFactory());
private static ZooKeeper zk;
private static ZkSessionManager zkSessionManager;
@Before
public void setup() throws Exception {
zk = newZooKeeper();
// be sure that the lock-place is created
ZkUtils.recursiveSafeDelete(zk, baseLockPath, -1);
zk.create(baseLockPath, new byte[] {}, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
zkSessionManager = new BaseZkSessionManager(zk);
}
@After
public void tearDown() throws Exception {
try {
List<String> children = zk.getChildren(baseLockPath, false);
for (String child : children) {
ZkUtils.safeDelete(zk, baseLockPath + "/" + child, -1);
}
ZkUtils.safeDelete(zk, baseLockPath, -1);
} catch (KeeperException ke) {
// suppress because who cares what went wrong after our tests did their thing?
} finally {
closeZooKeeper(zk);
}
}
@Test(timeout = 1500l)
public void testOnlyOneLockAllowedTwoThreads() throws Exception {
final CountDownLatch latch = new CountDownLatch(1);
Lock firstLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
firstLock.lock();
try {
testService.submit(
new Runnable() {
@Override
public void run() {
Lock secondLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
secondLock.lock();
try {
latch.countDown();
} finally {
secondLock.unlock();
}
}
});
boolean nowAcquired = latch.await(500, TimeUnit.MILLISECONDS);
assertTrue("The Second lock was acquired before the first lock was released!", !nowAcquired);
} finally {
firstLock.unlock();
}
}
@Test(timeout = 1500l)
public void testReentrancy() throws Exception {
final CountDownLatch latch = new CountDownLatch(1);
Lock firstLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
firstLock.lock();
try {
testService.submit(
new Runnable() {
@Override
public void run() {
Lock secondLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
secondLock.lock();
try {
latch.countDown();
} finally {
secondLock.unlock();
}
}
});
boolean nowAcquired = latch.await(500, TimeUnit.MILLISECONDS);
assertTrue("The Second lock was acquired before the first lock was released!", !nowAcquired);
// this should be fine
firstLock.lock();
System.out.println("Lock acquired twice!");
firstLock.unlock();
// should still be locked
nowAcquired = latch.await(500, TimeUnit.MILLISECONDS);
assertTrue(
"The Second lock was acquired before the first lock was released twice!", !nowAcquired);
} finally {
firstLock.unlock();
}
}
@Test(timeout = 1500l)
public void testMultipleThreadsCannotAccessSameLock() throws Exception {
final CountDownLatch latch = new CountDownLatch(1);
final Lock firstLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
firstLock.lock();
testService.submit(
new Runnable() {
@Override
public void run() {
firstLock.lock();
try {
latch.countDown();
} finally {
firstLock.unlock();
}
}
});
boolean acquired = latch.await(500, TimeUnit.MILLISECONDS);
assertTrue("The Lock was acquired twice by two separate threads!", !acquired);
firstLock.unlock();
acquired = latch.await(500, TimeUnit.MILLISECONDS);
assertTrue("The Lock was never acquired by another thread!", acquired);
}
@Test(timeout = 1000l)
public void testMultipleClientsCannotAccessSameLock() throws Exception {
final CountDownLatch latch = new CountDownLatch(1);
final Lock firstLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
final Lock sameLock =
new ReentrantZkLock(baseLockPath, new BaseZkSessionManager(newZooKeeper()));
firstLock.lock();
testService.submit(
new Runnable() {
@Override
public void run() {
sameLock.lock();
try {
latch.countDown();
} finally {
sameLock.unlock();
}
}
});
boolean acquired = latch.await(500, TimeUnit.MILLISECONDS);
assertTrue("The Lock was acquired twice by two separate threads!", !acquired);
firstLock.unlock();
acquired = latch.await(500, TimeUnit.MILLISECONDS);
assertTrue("The Lock was never acquired by another thread!", acquired);
}
@Test(timeout = 20000l)
@Ignore
public void testLockWorksUnderContentionDifferentClients() throws Exception {
int numThreads = 5;
final int numIterations = 100;
ExecutorService service = Executors.newFixedThreadPool(numThreads);
final CyclicBarrier startBarrier = new CyclicBarrier(numThreads + 1);
final CyclicBarrier endBarrier = new CyclicBarrier(numThreads + 1);
final UnsafeOperator operator = new UnsafeOperator();
for (int i = 0; i < numThreads; i++) {
service.submit(
new Callable<Void>() {
@Override
public Void call() throws Exception {
startBarrier.await(); // make sure all threads are in the same place before starting
// create the lock that we're going to use
ZooKeeper newZk = newZooKeeper();
try {
Lock testLock = new ReentrantZkLock(baseLockPath, new BaseZkSessionManager(newZk));
for (int j = 0; j < numIterations; j++) {
testLock.lock();
try {
operator.increment();
} finally {
testLock.unlock();
}
}
} finally {
closeZooKeeper(newZk);
}
// enter the end barrier to ensure that things are finished
endBarrier.await();
return null;
}
});
}
// start the test
startBarrier.await();
// wait for the end of the test
endBarrier.await();
// check that the number of operations that actually were recorded are correct
int correctOps = numIterations * numThreads;
assertEquals("Number of Operations recorded was incorrect!", correctOps, operator.getValue());
}
@Test(timeout = 20000l)
@Ignore
public void testLockWorksUnderContentionSameClient() throws Exception {
int numThreads = 5;
final int numIterations = 100;
ExecutorService service = Executors.newFixedThreadPool(numThreads);
final CyclicBarrier startBarrier = new CyclicBarrier(numThreads + 1);
final CyclicBarrier endBarrier = new CyclicBarrier(numThreads + 1);
final UnsafeOperator operator = new UnsafeOperator();
final Lock testLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
for (int i = 0; i < numThreads; i++) {
service.submit(
new Callable<Void>() {
@Override
public Void call() throws Exception {
startBarrier.await(); // make sure all threads are in the same place before starting
for (int j = 0; j < numIterations; j++) {
testLock.lock();
try {
operator.increment();
} finally {
testLock.unlock();
}
}
// enter the end barrier to ensure that things are finished
endBarrier.await();
return null;
}
});
}
// start the test
startBarrier.await();
// wait for the end of the test
endBarrier.await();
// check that the number of operations that actually were recorded are correct
int correctOps = numIterations * numThreads;
assertEquals("Number of Operations recorded was incorrect!", correctOps, operator.getValue());
}
@Test(timeout = 1500l)
public void testConditionWaitsForSignalOtherThread() throws Exception {
final Lock firstLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
final Condition firstCondition = firstLock.newCondition();
firstLock.lock();
// fire off a thread that will signal the main process thread
testService.submit(
new Runnable() {
@Override
public void run() {
firstLock.lock();
System.out.println("Lock acquired on second thread");
try {
firstCondition.signal();
System.out.println("Lock signalled on second thread");
} finally {
System.out.println("Lock released on second thread");
firstLock.unlock();
}
}
});
// wait for signal notification
System.out.println("First thread waiting for notification");
firstCondition.await();
System.out.println("First thread has been notified");
}
@Test(timeout = 1500l)
public void testConditionWaitsForSignalOtherClient() throws Exception {
final Lock firstLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
final Condition firstCondition = firstLock.newCondition();
firstLock.lock();
// fire off a thread that will signal the main process thread
Future<Void> errorFuture =
testService.submit(
new Callable<Void>() {
@Override
public Void call() throws Exception {
final Lock otherClientLock;
ZooKeeper newZk = newZooKeeper();
try {
otherClientLock =
new ReentrantZkLock(baseLockPath, new BaseZkSessionManager(newZk));
final Condition otherClientCondition = otherClientLock.newCondition();
otherClientLock.lock();
System.out.println("Lock acquired on second thread");
try {
otherClientCondition.signal();
System.out.println("Lock signalled on second thread");
} finally {
System.out.println("Lock released on second thread");
otherClientLock.unlock();
}
return null;
} finally {
closeZooKeeper(newZk);
}
}
});
// wait for signal notification
System.out.println("First thread waiting for notification");
firstCondition.await();
System.out.println("First thread has been notified");
firstLock.unlock();
errorFuture.get();
}
@Test(timeout = 1000l)
public void testConditionTimesOut() throws Exception {
Lock firstLock = new ReentrantZkLock(baseLockPath, zkSessionManager);
Condition firstCondition = firstLock.newCondition();
firstLock.lock();
boolean timedOut = firstCondition.await(250l, TimeUnit.MILLISECONDS);
assertTrue("Condition did not time out!", !timedOut);
firstLock.unlock();
}
private static ZooKeeper newZooKeeper() throws IOException {
System.out.printf("%s: Creating new ZooKeeper%n", Thread.currentThread().getName());
return new ZooKeeper(
hostString,
timeout,
new Watcher() {
@Override
public void process(WatchedEvent event) {
// System.out.println(event);
}
});
}
private static void closeZooKeeper(ZooKeeper zk) throws InterruptedException {
System.out.printf("%s: Closing ZooKeeper%n", Thread.currentThread().getName());
zk.close();
}
}
