@Override public void mkdirs(String path) throws KeeperException, InterruptedException { if (path.equals("")) return; if (!path.startsWith("/")) throw new IllegalArgumentException(path + "does not start with /"); if (exists(path)) return; String parent = path.substring(0, path.lastIndexOf("/")); mkdirs(parent); putPersistentData(path, new byte[] {}, NodeExistsPolicy.SKIP); }
public MasterTime(Master master) throws IOException { this.zPath = master.getZooKeeperRoot() + Constants.ZMASTER_TICK; this.zk = master.getContext().getZooReaderWriter(); this.master = master; try { zk.putPersistentData(zPath, "0".getBytes(UTF_8), NodeExistsPolicy.SKIP); skewAmount = Long.parseLong(new String(zk.getData(zPath, null), UTF_8)) - System.nanoTime(); } catch (Exception ex) { throw new IOException("Error updating master time", ex); } this.timer = new Timer(); timer.schedule(this, 0, MILLISECONDS.convert(10, SECONDS)); }
public static synchronized ZooReaderWriter getInstance(String zookeepers, int timeInMillis, String scheme, byte[] auth) { if (instance == null) instance = new ZooReaderWriter(zookeepers, timeInMillis, scheme, auth); return instance; }
/** * Ensure that the full path to ZooKeeper nodes that will be used exist */ public static void ensureZooKeeperInitialized(final ZooReaderWriter zooReaderWriter, final String zRoot) throws KeeperException, InterruptedException { if (!zooReaderWriter.exists(zRoot + ReplicationConstants.ZOO_TSERVERS, null)) { zooReaderWriter.mkdirs(zRoot + ReplicationConstants.ZOO_TSERVERS); } if (!zooReaderWriter.exists(zRoot + ReplicationConstants.ZOO_WORK_QUEUE, null)) { zooReaderWriter.mkdirs(zRoot + ReplicationConstants.ZOO_WORK_QUEUE); } } }
public void addWork(String workId, byte[] data) throws KeeperException, InterruptedException { if (workId.equalsIgnoreCase(LOCKS_NODE)) throw new IllegalArgumentException("locks is reserved work id"); zoo.mkdirs(path); zoo.putPersistentData(path + "/" + workId, data, NodeExistsPolicy.SKIP); }
if (zoo.exists(monitorPath)) { byte[] data = zoo.getData(monitorPath, null); zoo.recursiveDelete(monitorPath, NodeMissingPolicy.SKIP); zoo.putPersistentData(monitorPath, new byte[0], NodeExistsPolicy.FAIL); zoo.putPersistentData(monitorLockPath, new byte[0], NodeExistsPolicy.FAIL); } else if (!zoo.exists(monitorLockPath)) { zoo.putPersistentData(monitorLockPath, new byte[0], NodeExistsPolicy.FAIL); zoo.putPersistentData(zRoot + Constants.ZMONITOR, new byte[0], NodeExistsPolicy.FAIL); if (!zoo.exists(monitorLockPath)) { zoo.putPersistentData(monitorLockPath, new byte[0], NodeExistsPolicy.FAIL);
public void post(String server, String cause) { try { zoo.putPersistentData(path + "/" + server, cause.getBytes(UTF_8), NodeExistsPolicy.SKIP); } catch (Exception ex) { log.error("post failed with exception", ex); } } }
private String root() throws WalMarkerException { String root = context.getZooKeeperRoot() + ZWALS; try { if (!checkedExistance && !zoo.exists(root)) { zoo.putPersistentData(root, new byte[0], NodeExistsPolicy.SKIP); } checkedExistance = true; } catch (KeeperException | InterruptedException e) { throw new WalMarkerException(e); } return root; }
if (createValue != null) { while (true) { final Retry retry = getRetryFactory().createRetry(); try { getZooKeeper().create(zPath, createValue, acl, CreateMode.PERSISTENT); return createValue; } catch (KeeperException ex) { } else if (code == Code.OPERATIONTIMEOUT || code == Code.CONNECTIONLOSS || code == Code.SESSIONEXPIRED) { retryOrThrow(retry, ex); } else { throw ex; final Retry retry = getRetryFactory().createRetry(); Stat stat = new Stat(); byte[] data = getData(zPath, false, stat); data = mutator.mutate(data); if (data == null) return data; try { getZooKeeper().setData(zPath, data, stat.getVersion()); return data; } catch (KeeperException ex) { retryOrThrow(retry, ex); retry.waitForNextAttempt(); } else {
public MergeInfo getMergeInfo(Table.ID tableId) { synchronized (mergeLock) { try { String path = getZooKeeperRoot() + Constants.ZTABLES + "/" + tableId + "/merge"; if (!context.getZooReaderWriter().exists(path)) return new MergeInfo(); byte[] data = context.getZooReaderWriter().getData(path, new Stat()); DataInputBuffer in = new DataInputBuffer(); in.reset(data, data.length); MergeInfo info = new MergeInfo(); info.readFields(in); return info; } catch (KeeperException.NoNodeException ex) { log.info("Error reading merge state, it probably just finished"); return new MergeInfo(); } catch (Exception ex) { log.warn("Unexpected error reading merge state", ex); return new MergeInfo(); } } }
@Override public void revokeTablePermission(String user, String table, TablePermission permission) throws AccumuloSecurityException { byte[] serializedPerms = zooCache.get(ZKUserPath + "/" + user + ZKUserTablePerms + "/" + table); // User had no table permission, nothing to revoke. if (serializedPerms == null) return; Set<TablePermission> tablePerms = ZKSecurityTool.convertTablePermissions(serializedPerms); try { if (tablePerms.remove(permission)) { zooCache.clear(); if (tablePerms.size() == 0) zoo.recursiveDelete(ZKUserPath + "/" + user + ZKUserTablePerms + "/" + table, NodeMissingPolicy.SKIP); else zoo.putPersistentData(ZKUserPath + "/" + user + ZKUserTablePerms + "/" + table, ZKSecurityTool.convertTablePermissions(tablePerms), NodeExistsPolicy.OVERWRITE); } } catch (KeeperException e) { log.error("{}", e.getMessage(), e); throw new AccumuloSecurityException(user, SecurityErrorCode.CONNECTION_ERROR, e); } catch (InterruptedException e) { log.error("{}", e.getMessage(), e); throw new RuntimeException(e); } }
public List<DeadServer> getList() { List<DeadServer> result = new ArrayList<>(); try { List<String> children = zoo.getChildren(path); if (children != null) { for (String child : children) { Stat stat = new Stat(); byte[] data; try { data = zoo.getData(path + "/" + child, stat); } catch (NoNodeException nne) { // Another thread or process can delete child while this loop is running. // We ignore this error since it's harmless if we miss the deleted server // in the dead server list. continue; } DeadServer server = new DeadServer(child, stat.getMtime(), new String(data, UTF_8)); result.add(server); } } } catch (Exception ex) { log.error("{}", ex.getMessage(), ex); } return result; }
/** * @param args * : the name or UUID of the instance to be deleted */ public static void main(String[] args) throws Exception { Opts opts = new Opts(); opts.parseArgs(DeleteZooInstance.class.getName(), args); ZooReaderWriter zk = new ZooReaderWriter(new SiteConfiguration()); // try instance name: Set<String> instances = new HashSet<>(zk.getChildren(Constants.ZROOT + Constants.ZINSTANCES)); Set<String> uuids = new HashSet<>(zk.getChildren(Constants.ZROOT)); uuids.remove("instances"); if (instances.contains(opts.instance)) { String path = Constants.ZROOT + Constants.ZINSTANCES + "/" + opts.instance; byte[] data = zk.getData(path, null); deleteRetry(zk, path); deleteRetry(zk, Constants.ZROOT + "/" + new String(data, UTF_8)); } else if (uuids.contains(opts.instance)) { // look for the real instance name for (String instance : instances) { String path = Constants.ZROOT + Constants.ZINSTANCES + "/" + instance; byte[] data = zk.getData(path, null); if (opts.instance.equals(new String(data, UTF_8))) deleteRetry(zk, path); } deleteRetry(zk, Constants.ZROOT + "/" + opts.instance); } }
long getCompactionCancelID() { String zTablePath = Constants.ZROOT + "/" + tabletServer.getInstanceID() + Constants.ZTABLES + "/" + extent.getTableId() + Constants.ZTABLE_COMPACT_CANCEL_ID; try { return Long .parseLong(new String(context.getZooReaderWriter().getData(zTablePath, null), UTF_8)); } catch (KeeperException | InterruptedException e) { throw new RuntimeException(e); } }
try { try { processor.newProcessor().process(child, zoo.getData(childPath, null)); zoo.recursiveDelete(childPath, NodeMissingPolicy.SKIP); } catch (Exception e) { log.error("Error received when trying to delete entry in zookeeper " + childPath, zoo.recursiveDelete(lockPath, NodeMissingPolicy.SKIP); } catch (Exception e) { log.error("Error received when trying to delete entry in zookeeper " + childPath, lookForWork(processor, zoo.getChildren(path)); } catch (KeeperException e) { log.error("Failed to look for work", e);
@Override public boolean hasSystemPermission(String user, SystemPermission permission) { byte[] perms; try { String path = ZKUserPath + "/" + user + ZKUserSysPerms; zoo.sync(path); perms = zoo.getData(path, null); } catch (KeeperException e) { if (e.code() == Code.NONODE) { return false; } log.warn("Unhandled KeeperException, failing closed for table permission check", e); return false; } catch (InterruptedException e) { log.warn("Unhandled InterruptedException, failing closed for table permission check", e); return false; } if (perms == null) return false; return ZKSecurityTool.convertSystemPermissions(perms).contains(permission); }
zoo.putEphemeralData(lockPath, new byte[0]); } catch (NodeExistsException nee) { if (!zoo.exists(childPath)) { zoo.recursiveDelete(lockPath, NodeMissingPolicy.SKIP); continue; zoo.recursiveDelete(lockPath, NodeMissingPolicy.SKIP); break;
public List<Path> getWalsInUse(TServerInstance tsi) throws WalMarkerException { List<Path> result = new ArrayList<>(); try { String zpath = root() + "/" + tsi; zoo.sync(zpath); for (String child : zoo.getChildren(zpath)) { byte[] zdata = null; try { // This function is called by the Master. Its possible that Accumulo GC deletes an // unreferenced WAL in ZK after the call to getChildren above. Catch this exception inside // the loop so that not all children are ignored. zdata = zoo.getData(zpath + "/" + child, null); } catch (KeeperException.NoNodeException e) { log.debug("WAL state removed {} {} during getWalsInUse. Likely a race condition between " + "master and GC.", tsi, child); } if (zdata != null) { Pair<WalState,Path> parts = parse(zdata); if (parts.getFirst() != WalState.UNREFERENCED) { result.add(parts.getSecond()); } } } } catch (KeeperException.NoNodeException e) { log.debug("{} has no wal entry in zookeeper, assuming no logs", tsi); } catch (KeeperException | InterruptedException e) { throw new WalMarkerException(e); } return result; }
@Override public void delete(String path, int version) throws InterruptedException, KeeperException { final Retry retry = getRetryFactory().createRetry(); while (true) { try { getZooKeeper().delete(path, version); return; } catch (KeeperException e) { final Code code = e.code(); if (code == Code.NONODE) { if (retry.hasRetried()) { // A retried delete could have deleted the node, assume that was the case log.debug("Delete saw no node on a retry. Assuming node was deleted"); return; } throw e; } else if (code == Code.CONNECTIONLOSS || code == Code.OPERATIONTIMEOUT || code == Code.SESSIONEXPIRED) { // retry if we have more attempts to do so retryOrThrow(retry, e); } else { throw e; } } retry.waitForNextAttempt(); } }
public void removeNamespace(Namespace.ID namespaceId) throws KeeperException, InterruptedException { zoo.recursiveDelete(zkRoot + Constants.ZNAMESPACES + "/" + namespaceId, NodeMissingPolicy.SKIP); }