private static boolean zookeeperAvailable() { try { return zoo.exists("/"); } catch (KeeperException | InterruptedException e) { return false; } }
/** * 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); } } }
@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); }
@Override public void initializeSecurity(TCredentials itw, String rootuser) throws AccumuloSecurityException { ZooReaderWriter zoo = context.getZooReaderWriter(); // create the root user with all system privileges, no table privileges, and no record-level // authorizations Set<SystemPermission> rootPerms = new TreeSet<>(); for (SystemPermission p : SystemPermission.values()) rootPerms.add(p); Map<Table.ID,Set<TablePermission>> tablePerms = new HashMap<>(); // Allow the root user to flush the metadata tables tablePerms.put(MetadataTable.ID, Collections.singleton(TablePermission.ALTER_TABLE)); tablePerms.put(RootTable.ID, Collections.singleton(TablePermission.ALTER_TABLE)); try { // prep parent node of users with root username if (!zoo.exists(ZKUserPath)) zoo.putPersistentData(ZKUserPath, rootuser.getBytes(UTF_8), NodeExistsPolicy.FAIL); initUser(rootuser); zoo.putPersistentData(ZKUserPath + "/" + rootuser + ZKUserAuths, ZKSecurityTool.convertAuthorizations(Authorizations.EMPTY), NodeExistsPolicy.FAIL); } catch (KeeperException | InterruptedException e) { log.error("{}", e.getMessage(), e); throw new RuntimeException(e); } }
if (!zoo.exists(ZKUserPath)) zoo.putPersistentData(ZKUserPath, rootuser.getBytes(UTF_8), NodeExistsPolicy.FAIL);
/** * Remove the given {@link AuthenticationKey} from ZooKeeper. If the node for the provided * {@code key} doesn't exist in ZooKeeper, a warning is printed but an error is not thrown. Since * there is only a single process managing ZooKeeper at one time, any inconsistencies should be * client error. * * @param key * The key to remove from ZooKeeper */ public synchronized void remove(AuthenticationKey key) throws KeeperException, InterruptedException { checkState(initialized.get(), "Not initialized"); requireNonNull(key); String path = qualifyPath(key); if (!zk.exists(path)) { log.warn("AuthenticationKey with ID '{}' doesn't exist in ZooKeeper", key.getKeyId()); return; } log.debug("Removing AuthenticationKey with keyId {} from ZooKeeper at {}", key.getKeyId(), path); // Delete the node, any version zk.delete(path, -1); }
/** * Add the given {@link AuthenticationKey} to ZooKeeper. * * @param newKey * The key to add to ZooKeeper */ public synchronized void advertise(AuthenticationKey newKey) throws KeeperException, InterruptedException { checkState(initialized.get(), "Not initialized"); requireNonNull(newKey); // Make sure the node doesn't already exist String path = qualifyPath(newKey); if (zk.exists(path)) { log.warn("AuthenticationKey with ID '{}' already exists in ZooKeeper", newKey.getKeyId()); return; } // Serialize it ByteArrayOutputStream baos = new ByteArrayOutputStream(4096); try { newKey.write(new DataOutputStream(baos)); } catch (IOException e) { throw new AssertionError("Should not get exception writing to in-memory buffer", e); } byte[] serializedKey = baos.toByteArray(); log.debug("Advertising AuthenticationKey with keyId {} in ZooKeeper at {}", newKey.getKeyId(), path); // Put it into ZK with the private ACL zk.putPrivatePersistentData(path, serializedKey, NodeExistsPolicy.FAIL); }
if (!zoo.exists(childPath)) { zoo.recursiveDelete(lockPath, NodeMissingPolicy.SKIP); continue;
} else { exists = zoo.exists(instanceNamePath); if (exists) { String decision = getConsoleReader().readLine("Instance name \"" + instanceName
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 (!zk.exists(baseNode)) { if (!zk.putPrivatePersistentData(baseNode, new byte[0], NodeExistsPolicy.FAIL)) { throw new AssertionError("Got false from putPrivatePersistentData method");
@Override public void process(WatchedEvent event) { log.debug("event {} {} {}", event.getPath(), event.getType(), event.getState()); if (event.getState() == KeeperState.Expired) { log.warn("Trace server lost zookeeper registration at {} ", event.getPath()); server.stop(); } else if (event.getType() == EventType.NodeDeleted) { log.warn("Trace server zookeeper entry lost {}", event.getPath()); server.stop(); } if (event.getPath() != null) { try { if (context.getZooReaderWriter().exists(event.getPath(), this)) return; } catch (Exception ex) { log.error("{}", ex.getMessage(), ex); } log.warn("Trace server unable to reset watch on zookeeper registration"); server.stop(); } }
public static void main(String[] args) throws Exception { ServerUtilOpts opts = new ServerUtilOpts(); opts.parseArgs(MergeStats.class.getName(), args); try (AccumuloClient client = opts.createClient()) { Map<String,String> tableIdMap = client.tableOperations().tableIdMap(); ZooReaderWriter zooReaderWriter = opts.getServerContext().getZooReaderWriter(); for (Entry<String,String> entry : tableIdMap.entrySet()) { final String table = entry.getKey(), tableId = entry.getValue(); String path = ZooUtil.getRoot(client.getInstanceID()) + Constants.ZTABLES + "/" + tableId + "/merge"; MergeInfo info = new MergeInfo(); if (zooReaderWriter.exists(path)) { byte[] data = zooReaderWriter.getData(path, new Stat()); DataInputBuffer in = new DataInputBuffer(); in.reset(data, data.length); info.readFields(in); } System.out.println(String.format("%25s %10s %10s %s", table, info.getState(), info.getOperation(), info.getExtent())); } } } }
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 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); }