@Override public void close() throws IOException { zk.removeDefaultWatcher(watcher); schemaCache.close(); for (ServerNode node : servers) { Closer.close(node.repository); } if (managedZk && zk != null) { zk.close(); } // Close pools related to the Configuration objects managed by this LilyClient instance for (Configuration config : hbaseConnections.getConfigurations()) { LocalHTable.closePool(config); } // Close HBase connections created by [only] this LilyClient instance. // This will almost always contain only one connection, if not we would need a more // advanced connection mgmt so that these connections don't stay open for the lifetime // of LilyClient. Closer.close(hbaseConnections); this.isClosed = true; }
public void init() throws KeeperException, InterruptedException { ZkUtil.createPath(zk, REPOSITORY_COLLECTION_PATH); assureDefaultRepositoryExists(); zkWatcher = new RepositoryZkWatcher(); zk.addDefaultWatcher(zkWatcher); refresh(); }
@Override public void create(String repositoryName) throws RepositoryExistsException, InterruptedException, RepositoryModelException { if (!RepoDefUtil.isValidRepositoryName(repositoryName)) { throw new IllegalArgumentException( String.format( "'%s' is not a valid repository name. " + RepoDefUtil.VALID_NAME_EXPLANATION, repositoryName)); } RepositoryDefinition repoDef = new RepositoryDefinition(repositoryName, RepositoryLifecycleState.CREATE_REQUESTED); byte[] repoBytes = RepositoryDefinitionJsonSerDeser.INSTANCE.toJsonBytes(repoDef); try { zk.create( REPOSITORY_COLLECTION_PATH + "/" + repositoryName, repoBytes, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } catch (KeeperException.NodeExistsException e) { throw new RepositoryExistsException( "Can't create repository, a repository with this name already exists: " + repositoryName); } catch (KeeperException e) { throw new RepositoryModelException(e); } }
private void init() throws InterruptedException, KeeperException, NoServersException, RepositoryException { zk.addDefaultWatcher(watcher); refreshServers(); schemaCache.start(); this.isClosed = false; }
private static URI getDfsUri(ZooKeeperItf zk) { try { return new URI(new String(zk.getData(blobDfsUriPath, false, new Stat()))); } catch (Exception e) { throw new RuntimeException( "Blob stores config lookup: failed to get DFS URI from ZooKeeper", e); } }
private static BlobStoreAccessConfig getBlobStoreAccessConfig(ZooKeeperItf zk) { try { return new BlobStoreAccessConfig(zk.getData(blobStoreAccessConfigPath, false, new Stat())); } catch (Exception e) { throw new RuntimeException( "Blob stores config lookup: failed to get blob store access config from ZooKeeper", e); } }
private Map<String, RepositoryDefinition> loadRepositories(boolean watch) throws KeeperException, InterruptedException { Map<String, RepositoryDefinition> repositories = new HashMap<String, RepositoryDefinition>(); List<String> children = zk.getChildren(REPOSITORY_COLLECTION_PATH, watch ? zkWatcher : null); for (String child : children) { repositories.put(child, loadRepository(child, watch)); } return repositories; }
private void assureDefaultRepositoryExists() throws KeeperException, InterruptedException { byte[] repoBytes = RepositoryDefinitionJsonSerDeser.INSTANCE.toJsonBytes(DEFAULT_REPOSITORY); try { zk.create( REPOSITORY_COLLECTION_PATH + "/" + DEFAULT_REPOSITORY.getName(), repoBytes, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } catch (KeeperException.NodeExistsException e) { // it already exists, fine } }
@Override public void deleteDirect(String repositoryName) throws InterruptedException, RepositoryModelException, RepositoryNotFoundException { disallowDefaultRepository(repositoryName); try { zk.delete(REPOSITORY_COLLECTION_PATH + "/" + repositoryName, -1); } catch (KeeperException.NoNodeException e) { throw new RepositoryNotFoundException( "Can't delete repository, a repository with this name doesn't exist: " + repositoryName); } catch (KeeperException e) { throw new RepositoryModelException("Error deleting repository.", e); } }
public static Configuration getHBaseConfiguration(ZooKeeperItf zk) { try { Configuration configuration = HBaseConfiguration.create(); byte[] data = zk.getData(hbaseConfigPath, false, new Stat()); ObjectNode propertiesNode = (ObjectNode) JsonFormat.deserializeSoft(data, "HBase configuration"); Iterator<Map.Entry<String, JsonNode>> it = propertiesNode.getFields(); while (it.hasNext()) { Map.Entry<String, JsonNode> entry = it.next(); configuration.set(entry.getKey(), entry.getValue().getTextValue()); } return configuration; } catch (Exception e) { throw new RuntimeException("Failed to get HBase configuration from ZooKeeper", e); } }
private RepositoryDefinition loadRepository(String name, boolean watch) throws KeeperException, InterruptedException { byte[] repoJson = zk.getData(REPOSITORY_COLLECTION_PATH + "/" + name, watch ? zkWatcher : null, new Stat()); return RepositoryDefinitionJsonSerDeser.INSTANCE.fromJsonBytes(name, repoJson); }
public void storeRepository(RepositoryDefinition repoDef) throws InterruptedException, KeeperException { byte[] repoBytes = RepositoryDefinitionJsonSerDeser.INSTANCE.toJsonBytes(repoDef); zk.setData(REPOSITORY_COLLECTION_PATH + "/" + repoDef.getName(), repoBytes, -1); }
public void close() { zk.removeDefaultWatcher(zkWatcher); closed = true; }
private synchronized void refreshServers() throws InterruptedException, KeeperException { Set<String> currentServers = new HashSet<String>(); boolean retry; do { retry = false; try { currentServers.addAll(zk.getChildren(nodesPath, true)); } catch (KeeperException.NoNodeException e) { // The path does not exist: this can happen if the client is started before // any Lily server has ever been started, or when using the LilyLauncher // from the test framework and calling its resetLilyState JMX operation. // In this case, put a watcher to be notified when the path is created. Stat stat = zk.exists(nodesPath, true); if (stat == null) { if (log.isInfoEnabled()) { log.info("The path with Lily servers does not exist in ZooKeeper: " + nodesPath); } clearServers(); return; } else { // The node was created in between the getChildren and exists calls: retry retry = true; } } } while (retry); Set<String> removedServers = new HashSet<String>(); removedServers.addAll(serverAddresses); removedServers.removeAll(currentServers); Set<String> newServers = new HashSet<String>(); newServers.addAll(currentServers); newServers.removeAll(serverAddresses); if (log.isDebugEnabled()) { log.debug( "# current servers in ZK: " + currentServers.size() + ", # added servers: " + newServers.size() + ", # removed servers: " + removedServers.size()); } // Remove removed servers Iterator<ServerNode> serverIt = servers.iterator(); while (serverIt.hasNext()) { ServerNode server = serverIt.next(); if (removedServers.contains(server.lilyAddressAndPort)) { serverIt.remove(); Closer.close(server.repository); } } serverAddresses.removeAll(removedServers); // Add new servers for (String server : newServers) { servers.add(new ServerNode(server)); serverAddresses.add(server); } if (log.isInfoEnabled()) { log.info("Current Lily servers = " + serverAddresses.toString()); } }