public static async Task downloadFromZK(SolrZkClient zkClient, string zkPath, string filePath, CancellationToken token) { try { token.ThrowIfCancellationRequested(); var children = await zkClient.getChildren(zkPath, null, true); // If it has no children, it's a leaf node, write the associated data from the ZNode. // Otherwise, continue recursing, but write the associated data to a special file if any if (!children.Any()) { // If we didn't copy data down, then we also didn't create the file. But we still need a marker on the local // disk so create an empty file. if (await copyDataDown(zkClient, zkPath, filePath) == 0) { Debug.WriteLine("Download: " + filePath); File.Create(filePath); } } else { Directory.CreateDirectory(filePath); // Make parent dir. // ZK nodes, whether leaf or not can have data. If it's a non-leaf node and // has associated data write it into the special file. token.ThrowIfCancellationRequested(); Debug.WriteLine("Download: " + filePath); await copyDataDown(zkClient, zkPath, Path.Combine(filePath, ZKNODE_DATA_FILE)); foreach (var child in children) { var zkChild = zkPath; if (zkChild.EndsWith("/") == false) { zkChild += "/"; } zkChild += child; if (await isEphemeral(zkClient, zkChild)) { // Don't copy ephemeral nodes continue; } // Go deeper into the tree now await downloadFromZK(zkClient, zkChild, Path.Combine(filePath, child), token); } } } catch (Exception ex) { if (ex is KeeperException || ex is ThreadInterruptedException) { throw new IOException("Error downloading files from zookeeper path " + zkPath + " to " + filePath, SolrZkClient.checkInterrupted(ex)); } throw; } }
/// <summary> /// Check whether a config exists in Zookeeper /// </summary> /// <param name="configName">The config to check existance on</param> /// <returns>Whether the config exists or not</returns> /// <exception cref="IOException">If an I/O error occurs</exception> public async Task <bool> configExists(string configName) { try { return(await zkClient.exists(ConfigsZKnode + "/" + configName, true)); } catch (Exception ex) { if (ex is KeeperException || ex is ThreadInterruptedException) { throw new IOException("Error checking whether config exists", SolrZkClient.checkInterrupted(ex)); } throw; } }
/// <summary> /// Delete a config in ZooKeeper /// </summary> /// <param name="configName">The config to delete</param> /// <param name="token"></param> /// <exception cref="IOException">If an I/O error occurs</exception> public async Task deleteConfigDir(string configName, CancellationToken token) { try { await zkClient.clean(ConfigsZKnode + "/" + configName, token); } catch (Exception ex) { if (ex is KeeperException || ex is ThreadInterruptedException) { throw new IOException("Error checking whether config exists", SolrZkClient.checkInterrupted(ex)); } throw; } }
public async Task <List <string> > listConfigs() { try { return(await zkClient.getChildren(ConfigsZKnode, null, true)); } catch (KeeperException.NoNodeException) { return(new List <string>()); } catch (Exception ex) { if (ex is KeeperException || ex is ThreadInterruptedException) { throw new IOException("Error listing configs", SolrZkClient.checkInterrupted(ex)); } throw; } }
private static async Task uploadFileToZk(SolrZkClient zkClient, string zkNode, string file, Regex filenameExclusions) { var fielName = Path.GetFileName(file); if (filenameExclusions != null && filenameExclusions.Match(fielName ?? throw new InvalidOperationException("File name is empty")).Success) { //TODO: Log here //log.info("uploadToZK skipping '{}' due to filenameExclusions '{}'", filename, filenameExclusions); return; } try { // if the path exists (and presumably we're uploading data to it) just set its data if (Path.GetFileName(file).Equals(ZKNODE_DATA_FILE) && (await zkClient.exists(zkNode, true))) { await zkClient.setData(zkNode, file, true); } else { //Can't work async because it will try to create same path zkClient.makePath(zkNode, file, false, true).Wait(); } } catch (KeeperException ex) { throw new Exception("Error uploading file " + file + " to zookeeper path " + zkNode, SolrZkClient.checkInterrupted(ex)); } }
private async Task copyConfigDirFromZk(string fromZkPath, string toZkPath, ISet <string> copiedToZkPaths = null) { try { var files = await zkClient.getChildren(fromZkPath, null, true); foreach (var file in files) { var children = await zkClient.getChildren(fromZkPath + "/" + file, null, true); if (!children.Any()) { var toZkFilePath = toZkPath + "/" + file; //TODO: Log here //logger.info("Copying zk node {} to {}",fromZkPath + "/" + file, toZkFilePath); var data = await zkClient.getData(fromZkPath + "/" + file, null, null, true); //Take care it fails on Exists await zkClient.makePath(toZkFilePath, data, true); copiedToZkPaths?.Add(toZkFilePath); } else { await copyConfigDirFromZk(fromZkPath + "/" + file, toZkPath + "/" + file, copiedToZkPaths); } } } catch (Exception ex) { if (ex is KeeperException || ex is ThreadInterruptedException) { throw new IOException("Error copying nodes from zookeeper path " + fromZkPath + " to " + toZkPath, SolrZkClient.checkInterrupted(ex)); } throw; } }