private void getMasterLock(final String zMasterLoc) throws KeeperException, InterruptedException { log.info("trying to get master lock"); final String masterClientAddress = hostname + ":" + getConfiguration().getPort(Property.MASTER_CLIENTPORT)[0]; while (true) { MasterLockWatcher masterLockWatcher = new MasterLockWatcher(); masterLock = new ZooLock(getContext().getZooReaderWriter(), zMasterLoc); masterLock.lockAsync(masterLockWatcher, masterClientAddress.getBytes()); masterLockWatcher.waitForChange(); if (masterLockWatcher.acquiredLock) { break; } if (!masterLockWatcher.failedToAcquireLock) { throw new IllegalStateException("master lock in unknown state"); } masterLock.tryToCancelAsyncLockOrUnlock(); sleepUninterruptibly(TIME_TO_WAIT_BETWEEN_LOCK_CHECKS, TimeUnit.MILLISECONDS); } setMasterState(MasterState.HAVE_LOCK); }
private static String getMaster(ZooCache cache, UUID iid, boolean printErrors) { if (iid == null) { return null; } try { String masterLocPath = Constants.ZROOT + "/" + iid + Constants.ZMASTER_LOCK; byte[] master = ZooLock.getLockData(cache, masterLocPath, null); if (master == null) { return null; } return new String(master, UTF_8); } catch (Exception e) { handleException(e, printErrors); return null; } }
public long getSessionId() throws KeeperException, InterruptedException { return getSessionId(getLockDataZooCache, path); }
if (tabletServerLock == null || !tabletServerLock.wasLockAcquired()) { log.debug("Got {} message before my lock was acquired, ignoring...", request); throw new RuntimeException("Lock not acquired"); if (tabletServerLock != null && tabletServerLock.wasLockAcquired() && !tabletServerLock.isLocked()) { Halt.halt(1, new Runnable() { @Override if (!ZooLock.isLockHeld(masterLockCache, lid)) { if (!ZooLock.isLockHeld(masterLockCache, lid)) { log.warn("Got {} message from a master that does not hold the current lock {}", request, lock);
private void getZooLock(HostAndPort addr) throws KeeperException, InterruptedException { String path = context.getZooKeeperRoot() + Constants.ZGC_LOCK; LockWatcher lockWatcher = new LockWatcher() { @Override public void lostLock(LockLossReason reason) { Halt.halt("GC lock in zookeeper lost (reason = " + reason + "), exiting!", 1); } @Override public void unableToMonitorLockNode(final Throwable e) { // ACCUMULO-3651 Level changed to error and FATAL added to message for slf4j compatibility Halt.halt(-1, new Runnable() { @Override public void run() { log.error("FATAL: No longer able to monitor lock node ", e); } }); } }; while (true) { lock = new ZooLock(context.getZooReaderWriter(), path); if (lock.tryLock(lockWatcher, new ServerServices(addr.toString(), Service.GC_CLIENT).toString().getBytes())) { log.debug("Got GC ZooKeeper lock"); return; } log.debug("Failed to get GC ZooKeeper lock, will retry"); sleepUninterruptibly(1, TimeUnit.SECONDS); } }
tabletServerLock = new ZooLock(zoo, zPath); zoo.putPersistentData(zPath, new byte[0], NodeExistsPolicy.SKIP); if (tabletServerLock.tryLock(lw, lockContent)) { log.debug("Obtained tablet server lock {}", tabletServerLock.getLockPath()); lockID = tabletServerLock.getLockID() .serialize(context.getZooKeeperRoot() + Constants.ZTSERVERS + "/"); return;
public synchronized boolean tryLock(LockWatcher lw, byte data[]) throws KeeperException, InterruptedException { TryLockAsyncLockWatcher tlalw = new TryLockAsyncLockWatcher(lw); lockAsync(tlalw, data); if (tlalw.acquiredLock) { return true; } if (asyncLock != null) { zooKeeper.recursiveDelete(path + "/" + asyncLock, NodeMissingPolicy.SKIP); asyncLock = null; } return false; }
public static void main(String[] args) throws Exception { try (ServerContext context = new ServerContext(new SiteConfiguration())) { String tserverPath = context.getZooKeeperRoot() + Constants.ZTSERVERS; Opts opts = new Opts(); opts.parseArgs(TabletServerLocks.class.getName(), args); ZooCache cache = context.getZooCache(); ZooReaderWriter zoo = context.getZooReaderWriter(); if (opts.list) { List<String> tabletServers = zoo.getChildren(tserverPath); for (String tabletServer : tabletServers) { byte[] lockData = ZooLock.getLockData(cache, tserverPath + "/" + tabletServer, null); String holder = null; if (lockData != null) { holder = new String(lockData, UTF_8); } System.out.printf("%32s %16s%n", tabletServer, holder); } } else if (opts.delete != null) { ZooLock.deleteLock(zoo, tserverPath + "/" + args[1]); } else { System.out.println( "Usage : " + TabletServerLocks.class.getName() + " -list|-delete <tserver lock>"); } } }
public synchronized boolean tryToCancelAsyncLockOrUnlock() throws InterruptedException, KeeperException { boolean del = false; if (asyncLock != null) { zooKeeper.recursiveDelete(path + "/" + asyncLock, NodeMissingPolicy.SKIP); del = true; } if (lock != null) { unlock(); del = true; } return del; }
@Override public Repo<Master> call(long tid, Master master) throws Exception { // suppress assignment of tablets to the server if (force) { ZooReaderWriter zoo = master.getContext().getZooReaderWriter(); String path = master.getZooKeeperRoot() + Constants.ZTSERVERS + "/" + server.getLocation(); ZooLock.deleteLock(zoo, path); path = master.getZooKeeperRoot() + Constants.ZDEADTSERVERS + "/" + server.getLocation(); zoo.putPersistentData(path, "forced down".getBytes(UTF_8), NodeExistsPolicy.OVERWRITE); } return null; }
if (!ZooLock.isLockHeld(context.getZooCache(), lid)) {
private String lockString(ZooLock mlock) { return mlock.getLockID().serialize(context.getZooKeeperRoot() + Constants.ZMASTER_LOCK); }
public synchronized void replaceLockData(byte[] b) throws KeeperException, InterruptedException { if (getLockPath() != null) zooKeeper.getZooKeeper().setData(getLockPath(), b, -1); }
@Override public synchronized void process(WatchedEvent event) { log.debug("event {} {} {}", event.getPath(), event.getType(), event.getState()); watchingParent = false; if (event.getState() == KeeperState.Expired && lock != null) { lostLock(LockLossReason.SESSION_EXPIRED); } else { try { // set the watch on the parent node again zooKeeper.getStatus(path, this); watchingParent = true; } catch (KeeperException.ConnectionLossException ex) { // we can't look at the lock because we aren't connected, but our session is still good log.warn("lost connection to zookeeper"); } catch (Exception ex) { if (lock != null || asyncLock != null) { lockWatcher.unableToMonitorLockNode(ex); log.error( "Error resetting watch on ZooLock " + lock == null ? asyncLock : lock + " " + event, ex); } } } }
lockAsync(myLock, lw);
@Override public void run() { log.info("Master requested tablet server halt"); gcLogger.logGCInfo(TabletServer.this.getConfiguration()); serverStopRequested = true; try { tabletServerLock.unlock(); } catch (Exception e) { log.error("Caught exception unlocking TabletServer lock", e); } } });
String path = tserversPath + "/" + child; if (zoo.getChildren(path).size() > 0) { if (!ZooLock.deleteLock(zoo, path, "tserver")) { message("Did not delete " + tserversPath + "/" + child, opts);
lockHeld = ZooLock.isLockHeld(zooCache, new ZooUtil.LockID(zooRoot, lockId)); } catch (Exception e) { log.debug("Failed to verify lock was held {} {}", lockId, e.getMessage());
private static void retryZooKeeperUpdate(ServerContext context, ZooLock zooLock, ZooOperation op) { while (true) { try { IZooReaderWriter zoo = context.getZooReaderWriter(); if (zoo.isLockHeld(zooLock.getLockID())) { op.run(zoo); } break; } catch (Exception e) { log.error("Unexpected exception {}", e.getMessage(), e); } sleepUninterruptibly(1, TimeUnit.SECONDS); } }
public synchronized void replaceLockData(byte[] b) throws KeeperException, InterruptedException { if (getLockPath() != null) zooKeeper.getZooKeeper().setData(getLockPath(), b, -1); }