public async Task <NodeStatus> GetNodeStatusAsync([NotNull] string path)
{
ValidateState();
var stat = await _zk.existsAsync(path, true);
return(stat == null ? null : new NodeStatus(stat));
}
internal async void Run()
{
var data = Encoding.UTF8.GetBytes("test");
ZooKeeper zk = new ZooKeeper("localhost:2181", 50000, NullWatcher.Instance);
var zNodeRoot = zk.existsAsync("/").Result.getCversion();
var zNodeA = zk.existsAsync("/a").Result;
if (zNodeA == null)
{
await zk.createAsync("/a", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
var node = zk.existsAsync("/a/1").Result;
Task <string> nodetask = null;
if (node == null)
{
nodetask = zk.createAsync("/a/1", data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
}
nodetask.Wait();
IList <string> children = zk.getChildrenAsync("/a", false).Result.Children;
var test2 = zk.getDataAsync("/a", NodeWatcher.Instance).Result;
var test3 = zk.setDataAsync("/a", data).Result;
var closeEvent = zk.closeAsync();
closeEvent.Wait();
}
public void Dispose()
{
var zk = new ZooKeeper("localhost:2181", 3000, null);
if (zk.existsAsync("/AccountApp").GetAwaiter().GetResult() != null)
{
zk.deleteAsync("/AccountApp/Rate/USD").GetAwaiter().GetResult();
zk.deleteAsync("/AccountApp/Rate").GetAwaiter().GetResult();
zk.deleteAsync("/AccountApp").GetAwaiter().GetResult();
}
byte[] auth = Encoding.UTF8.GetBytes("user1:pass1");
zk.addAuthInfo("digest", auth);
if (zk.existsAsync("/AccountAppAuth").GetAwaiter().GetResult() != null)
{
zk.deleteAsync("/AccountAppAuth/Rate/USD").GetAwaiter().GetResult();
zk.deleteAsync("/AccountAppAuth/Rate").GetAwaiter().GetResult();
zk.deleteAsync("/AccountAppAuth").GetAwaiter().GetResult();
}
if (zk.existsAsync("/AccountAppAuth2").GetAwaiter().GetResult() != null)
{
zk.deleteAsync("/AccountAppAuth2/Rate/USD").GetAwaiter().GetResult();
zk.deleteAsync("/AccountAppAuth2/Rate").GetAwaiter().GetResult();
zk.deleteAsync("/AccountAppAuth2").GetAwaiter().GetResult();
}
zk.closeAsync().GetAwaiter().GetResult();
}
private async Task CreateSubdirectory(ZooKeeper zooKeeper, string path)
{
if (await zooKeeper.existsAsync(path) != null)
{
return;
}
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation($"节点{path}不存在，将进行创建。");
}
var childrens = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
var nodePath = "/";
foreach (var children in childrens)
{
nodePath += children;
if (await zooKeeper.existsAsync(nodePath) == null)
{
await zooKeeper.createAsync(nodePath, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
nodePath += "/";
}
}
/// <summary>
/// 请求一个任务
/// </summary>
/// <param name="taskType">任务类型</param>
/// <param name="taskId">任务ID</param>
/// <returns>是否请求成功</returns>
public bool RequireTask(string majorTaskId, string taskId, string serviceId)
{
try
{
var taskTodoPath = ConstData.TodoTaskPath.Format(majorTaskId, taskId);
var path = ConstData.InProgressPath.Format(majorTaskId, taskId);
// 待办路径不存在，请求任务失败
if (zkClient.existsAsync(taskTodoPath).GetAwaiter().GetResult() == null)
{
return(false);
}
if (zkClient.existsAsync(path).GetAwaiter().GetResult() == null)
{
ensurePath(path);
zkClient.createAsync(path, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL).GetAwaiter().GetResult();
return(true);
}
return(false);
}
catch (KeeperException.NodeExistsException)
{
return(false);
}
}
private string OpenNode(string nodename)
{
string result = "";
Stat NodeExists = null;
while (NodeExists == null)
{
try
{
NodeExists = _client.existsAsync(nodename).Result;
if (NodeExists == null)
{
result = _client.createAsync(nodename, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT).Result;
}
else
{
result = nodename;
}
}
catch (Exception ex)
{
if (ex.Message.IndexOf("NodeExistsException") == -1)
{
throw ex;
}
}
}
_client.existsAsync(nodename, true);
return(result);
}
/// <summary>
/// 初始化
/// </summary>
public void Initialize(string hostName, TcpUri basicCommunicationAddress)
{
_basePath = SystemWorker.ConfigurationProxy.GetField("kae-system", "ZooKeeperBasePath", false);
if (_client.existsAsync(_basePath, false).Result == null)
{
try { _client.createAsync(_basePath, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT).Wait(); }
catch (Exception) { }
}
//hosting node.
string hostingPath = Path.Combine(_basePath, "hosting");
hostingPath = hostingPath.Replace("\\", "/");
if (_client.existsAsync(hostingPath, false).Result == null)
{
try { _client.createAsync(hostingPath, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT).Wait(); }
catch (Exception) { }
}
//protocols node.
_protocolPath = Path.Combine(_basePath, "protocols");
_protocolPath = _protocolPath.Replace("\\", "/");
if (_client.existsAsync(_protocolPath, false).Result == null)
{
try { _client.createAsync(_protocolPath, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT).Wait(); }
catch (Exception) { }
}
//create resource node.
string resourcePath = Path.Combine(_basePath, "hosting/", hostName);
resourcePath = resourcePath.Replace("\\", "/");
if (_client.existsAsync(resourcePath, false).Result == null)
{
try { _client.createAsync(resourcePath, Encoding.UTF8.GetBytes(basicCommunicationAddress.ToString()), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL).Wait(); }
catch (Exception) { }
}
}
static async Task Test()
{
var output = string.Empty;
ZooKeeper zk = null;
try
{
//创建一个Zookeeper实例，第一个参数为目标服务器地址和端口，第二个参数为Session超时时间，第三个为节点变化时的回调方法
ZooKeeper.LogToFile = false;
ZooKeeper.LogToTrace = true;
zk = new ZooKeeper("127.0.0.1:2181", 10 * 1000, NullWatcher.Instance);
var stat = await zk.existsAsync("/root", true);
if (stat == null)
{
//创建一个节点root，数据是mydata,不进行ACL权限控制，节点为永久性的(即客户端shutdown了也不会消失)
output = await zk.createAsync("/root", "mydata".GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
Trace.WriteLine($"output");
}
stat = await zk.existsAsync("/root/childone", true);
if (stat == null)
{
//在root下面创建一个childone znode,数据为childone,不进行ACL权限控制，节点为永久性的
output = await zk.createAsync("/root/childone", "childone".GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
Trace.WriteLine($"output");
}
//取得/root节点下的子节点名称,返回List<String>
var subNodes = await zk.getChildrenAsync("/root", true);
Trace.WriteLine($"SubNodes: {(string.Join(",", subNodes.Children))}");
//取得/root/childone节点下的数据,返回byte[]
var data = await zk.getDataAsync("/root/childone", true);
Trace.WriteLine($"/root/childone Data: {Encoding.UTF8.GetString(data.Data)}");
//修改节点/root/childone下的数据，第三个参数为版本，如果是-1，那会无视被修改的数据版本，直接改掉
await zk.setDataAsync("/root/childone", "childonemodify".GetBytes(), -1);
//删除/root/childone这个节点，第二个参数为版本，－1的话直接删除，无视版本
await zk.deleteAsync("/root/childone", -1);
}
catch (Exception ex)
{
Trace.WriteLine(ex.StackTrace);
}
finally
{
await zk.closeAsync();
}
}
/// <summary>
/// 判断路径是否存在
/// </summary>
/// <param name="path"></param>
/// <param name="watcher"></param>
/// <returns></returns>
public Stat Exists(string path, Watcher watcher = null)
{
if (watcher == null)
{
return(_zk.existsAsync(path).ConfigureAwait(false).GetAwaiter().GetResult());
}
return(_zk.existsAsync(path, watcher).ConfigureAwait(false).GetAwaiter().GetResult());
}
private async Task AddRootNode()
{
var rootNode = await _zookeeper.existsAsync(_nodeName);
if (rootNode == null)
{
//Add application node
await _zookeeper.createAsync(_nodeName, Encoding.UTF8.GetBytes(_nodeName), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
_leaderCheckReady = true;
}
//TODO: Func here
//public Watcher wrapWatcher(final Watcher watcher) {
/// <summary>
/// Return the stat of the node of the given path. Return null if no such a
/// node exists.
/// If the watch is non-null and the call is successful (no exception is thrown),
/// a watch will be left on the node with the given path. The watch will be
/// triggered by a successful operation that creates/delete the node or sets
/// the data on the node.
/// </summary>
/// <param name="path">The node path</param>
/// <param name="watcher">Explicit watcher</param>
/// <param name="retryOnConnLoss"></param>
/// <returns>The stat of the node of the given path; return null if no such a node exists.</returns>
/// <exception cref="KeeperException">If the server signals an error</exception>.
public async Task <Stat> exists(string path, Watcher watcher, bool retryOnConnLoss)
{
if (retryOnConnLoss)
{
return(await _zkCmdExecutor.RetryOperation(async() => await keeper.existsAsync(path, watcher)));
}
else
{
return(await keeper.existsAsync(path, watcher));
}
}
public async Task testNullData()
{
const string path = "/SIZE";
ZooKeeper zk = await createClient();
await zk.createAsync(path, null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
// try sync zk exists
await zk.existsAsync(path, false);
Assert.assertTrue(await zk.existsAsync(path, false).WithTimeout(10 * 1000));
}
/// <summary>
/// 判断节点是否存在
/// </summary>
/// <param name="path">不要使用path等关键字作为路径</param>
/// <param name="watcher"></param>
/// <returns></returns>
public string ExistsNode(string path, Watcher watcher = null)
{
Task <org.apache.zookeeper.data.Stat> stat = _zooKeeper.existsAsync(path, watcher);
stat.Wait();
if (stat.Result != null && stat.Status.ToString().ToLower() == "RanToCompletion".ToLower())
{
return(_success);
}
return(_fail);
}
/// <summary>
/// 加锁方法
/// </summary>
/// <param name="lockname">锁名称</param>
/// <returns>{加锁结果 Result ,锁id Id}</returns>
public LockModel Lock(string lockname)
{
lock (_lockerList)
{
var node = _lockerList.FirstOrDefault(c => c.Name == lockname);
if (node != null)
{
return(new LockModel()
{
Result = LockResult.LockExists, Id = node.Id
});
}
}
try
{
if (!string.IsNullOrWhiteSpace(_client.createAsync($"/locks/{lockname}", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL).Result))
{
//增加监听
var watherResult = _client.existsAsync($"/locks/{lockname}", true).Result;
//增加到本地缓存
lock (_lockerList)
{
_lockerList.Add(new ZkLockerWatcher()
{
Name = lockname, Event = null, Id = watherResult?.getCtime() ?? 0
});
}
return(new LockModel()
{
Result = LockResult.Success, Id = watherResult.getCtime()
});
}
else
{
return(new LockModel()
{
Result = LockResult.Fail, Id = 0
});
}
}
catch (Exception)
{
return(new LockModel()
{
Result = LockResult.Fail, Id = 0
});
}
}
public static async Task <bool> ExistAsync_(this ZooKeeper client, string path, Watcher watcher = null)
{
if (watcher == null)
{
var res = await client.existsAsync(path, watch : false);
return(res != null);
}
else
{
var res = await client.existsAsync(path, watcher);
return(res != null);
}
}
private string OpenNode(string nodename)
{
string result = "";
Stat NodeExists = null;
while (NodeExists == null)
{
try
{
NodeExists = _client.existsAsync(nodename).Result;
if (NodeExists == null)
{
result = _client.createAsync(nodename, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT).Result;
}
else
{
result = nodename;
}
}
catch (Exception ex)
{
if (ex.HResult != (int)KeeperException.Code.NODEEXISTS)
{
throw ex;
}
}
}
return(result);
}
public async Task testNonExistingOpCode()
{
ZooKeeper zk = await createClient();
const string path = "/m1";
RequestHeader h = new RequestHeader();
h.set_Type(888); // This code does not exists
ExistsRequest request = new ExistsRequest();
request.setPath(path);
request.setWatch(false);
ExistsResponse response = new ExistsResponse();
ReplyHeader r = await zk.cnxn.submitRequest(h, request, response, null);
Assert.assertEquals(r.getErr(), (int)KeeperException.Code.UNIMPLEMENTED);
try {
await zk.existsAsync("/m1", false);
Assert.fail("The connection should have been closed");
}
catch (KeeperException.ConnectionLossException) {
}
}
public async Task testWatcherCorrectness()
{
ZooKeeper zk = null;
MyWatcher watcher = new MyWatcher();
zk = await createClient(watcher);
string[] names = new string[10];
for (int i = 0; i < names.Length; i++)
{
string name = await zk.createAsync("/tc-", "initialvalue".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
names[i] = name;
Stat stat = (await zk.getDataAsync(name, watcher)).Stat;
await zk.setDataAsync(name, "new".UTF8getBytes(), stat.getVersion());
stat = await zk.existsAsync(name, watcher);
await zk.deleteAsync(name, stat.getVersion());
}
for (int i = 0; i < names.Length; i++)
{
string name = names[i];
WatchedEvent @event = watcher.events.poll(10 * 1000);
Assert.assertEquals(name, @event.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeDataChanged, @event.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, @event.getState());
@event = watcher.events.poll(10 * 1000);
Assert.assertEquals(name, @event.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeDeleted, @event.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, @event.getState());
}
}
private async Task becomeReady(LeaderOffer neighborLeaderOffer)
{
await dispatchEvent(ElectionEventType.READY_START).ConfigureAwait(false);
logger.debugFormat("{0} not elected leader. Watching node:{1}", leaderOffer.NodePath,
neighborLeaderOffer.NodePath);
/*
* Make sure to pass an explicit Watcher because we could be sharing this
* zooKeeper instance with someone else.
*/
var stat = await ZooKeeper.existsAsync(neighborLeaderOffer.NodePath, electionWatcher).ConfigureAwait(false);
if (stat != null)
{
logger.debugFormat("We're behind {0} in line and they're alive. Keeping an eye on them.",
neighborLeaderOffer.NodePath);
state = State.READY;
await dispatchEvent(ElectionEventType.READY_COMPLETE).ConfigureAwait(false);
}
else
{
/*
* If the stat fails, the node has gone missing between the call to
* getChildren() and exists(). We need to try and become the leader.
*/
logger.debugFormat("We were behind {0} but it looks like they died. Back to determination.",
neighborLeaderOffer.NodePath);
await determineElectionStatus().ConfigureAwait(false);
}
}
public async Task testDeleteRecursive()
{
ZooKeeper zk = await createClient();
// making sure setdata works on /
await zk.setDataAsync("/", "some".UTF8getBytes(), -1);
await zk.createAsync("/a", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/a/b", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/a/b/v", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/a/b/v/1", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/a/c", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/a/c/v", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
IList <string> children = (await zk.getChildrenAsync("/a", false)).Children;
Assert.assertEquals("2 children - b & c should be present ", children.Count, 2);
Assert.assertTrue(children.Contains("b"));
Assert.assertTrue(children.Contains("c"));
ZKUtil.deleteRecursiveAsync(zk, "/a").GetAwaiter().GetResult();
Assert.assertNull(await zk.existsAsync("/a", null));
}
private void Init()
{
try
{
connectionResetEvent = new AutoResetEvent(false);
zk = new ZooKeeper(config, SessionTimeout, this);
Trace.WriteLine($"ThreadID: {Thread.CurrentThread.ManagedThreadId} zk connect");
//由于ZK客户端连接服务器是异步的，因此，此处阻塞线程，
//防止连接还没有建立就调用ZK客户端导致异常；
connectionResetEvent.WaitOne();
connectionResetEvent.Dispose();
connectionResetEvent = null;
var stat = zk.existsAsync(rootNode, false).Sync();
if (stat == null)
{
// 创建根节点
zk.createAsync(rootNode, EmptyData, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT).Sync();
}
}
catch (KeeperException e)
{
throw e;
}
}
/// <summary>
/// 判断节点是否存在
/// </summary>
/// <param name="path">不要使用path等关键字作为路径</param>
/// <param name="watcher"></param>
/// <returns></returns>
public string ExistsNode(string path, Watcher watcher = null)
{
try
{
Task <org.apache.zookeeper.data.Stat> stat = _zooKeeper.existsAsync(path, watcher);
stat.Wait();
if (stat.Result != null && stat.Status.ToString().ToLower() == "RanToCompletion".ToLower())
{
return(_success);
}
}
catch (Exception ex)
{
_log.ErrorFormat("判定节点存在与否发生异常：{0},{1}", path, ex.Message + ex.StackTrace);
}
return(_fail);
}
public ZkLocker(string lockName, ZkOption option, int lockTimeout = 5000)
{
_client = option.SessionId == long.MinValue
? new ZooKeeper(option.ConnectionsString, option.SessionTimeout, this, option.CanBeReadOnly)
: new ZooKeeper(option.ConnectionsString, option.SessionTimeout, this, option.SessionId,
option.SessionPassword, option.CanBeReadOnly);
if (_client.existsAsync("/locks").Result == null)
{
_client.createAsync("/locks", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT).Wait();
}
if (_client.existsAsync("/locks/" + lockName).Result == null)
{
_client.createAsync("/locks/" + lockName, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT).Wait();
}
_lockName = lockName;
_lockTimeout = lockTimeout;
}
/// <summary>
/// 清空所有的服务路由。
/// </summary>
/// <returns>一个任务。</returns>
public override async Task ClearAsync()
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("准备清空所有路由配置。");
}
var path = _configInfo.RoutePath;
var childrens = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
var index = 0;
while (childrens.Any())
{
var nodePath = "/" + string.Join("/", childrens);
if (await _zooKeeper.existsAsync(nodePath) != null)
{
var result = await _zooKeeper.getChildrenAsync(nodePath);
if (result?.Children != null)
{
foreach (var child in result.Children)
{
var childPath = $"{nodePath}/{child}";
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"准备删除：{childPath}。");
}
await _zooKeeper.deleteAsync(childPath);
}
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"准备删除：{nodePath}。");
}
await _zooKeeper.deleteAsync(nodePath);
}
index++;
childrens = childrens.Take(childrens.Length - index).ToArray();
}
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("路由配置清空完成。");
}
}
/**
* Make sure all the nodes in the path are created. NOTE: Unlike File.mkdirs(), Zookeeper doesn't distinguish
* between directories and files. So, every node in the path is created. The data for each node is an empty blob
*
* @param zookeeper the client
* @param path path to ensure
* @param makeLastNode if true, all nodes are created. If false, only the parent nodes are created
* @param aclProvider if not null, the ACL provider to use when creating parent nodes
* @param asContainers if true, nodes are created as {@link CreateMode#CONTAINER}
* @throws InterruptedException thread interruption
* @throws org.apache.zookeeper.KeeperException Zookeeper errors
*/
public static async void mkdirs(ZooKeeper zookeeper,
String path,
bool makeLastNode,
IInternalACLProvider aclProvider,
bool asContainers)
{
PathUtils.validatePath(path);
int pos = 1; // skip first slash, root is guaranteed to exist
do
{
pos = path.IndexOf(PATH_SEPARATOR, pos + 1);
if (pos == -1)
{
if (makeLastNode)
{
pos = path.Length;
}
else
{
break;
}
}
String subPath = path.Substring(0, pos);
if (await zookeeper.existsAsync(subPath, false) == null)
{
try
{
IList <ACL> acl = null;
if (aclProvider != null)
{
acl = aclProvider.getAclForPath(subPath);
if (acl == null)
{
acl = aclProvider.getDefaultAcl();
}
}
if (acl == null)
{
acl = ZooDefs.Ids.OPEN_ACL_UNSAFE;
}
await zookeeper.createAsync(subPath,
new byte[0],
acl.ToList(),
getCreateMode(asContainers))
.ConfigureAwait(false);
}
catch (KeeperException.NodeExistsException)
{
// ignore... someone else has created it since we checked
}
}
}while (pos < path.Length);
}
protected virtual void CreateRootNodeIfNotExist(string nodeName)
{
var stat = zk.existsAsync(nodeName, false).Sync();
if (stat == null)
{
var nodePath = zk.createAsync(nodeName, ZooKeeperDefaults.EmptyData, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT).Sync();
SafeLog($"create znode {nodePath}");
}
}
public ZookeeperDistributedLock()
{
zk = new ZooKeeper(zooKeeperConnectstring, 60 * 1000, NullWatcher.Instance);
var stat = zk.existsAsync(lockRoot, true).Run();
if (stat == null)
{
zk.createAsync(lockRoot, EmptyData, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT).Run();
}
}
public Task <DataResult> GetDataAsync(string path, Watcher watcher, bool isSync)
{
ReConn();
if (_zookeeper.existsAsync(path).Result == null)
{
_logger.LogDebug("path不存在");
return(null);
}
if (isSync)
{
_logger.LogDebug("即将进行同步。");
var task = Task.Run(async() => {
await _zookeeper.sync(path);
});
task.Wait();
}
return(_zookeeper.getDataAsync(path, watcher));
}
public async Task <bool> execute()
{
Stat stat = await zookeeper.existsAsync(path).ConfigureAwait(false);
if (stat != null)
{
return(true);
}
await zookeeper.createAsync(path, data, acl, flags).ConfigureAwait(false);
return(true);
}
public async Task testOnlyOneAvailable()
{
log.debug("START - testOnlyOneAvailable");
var connectionString = Enumerable.Range(0, 9).Select(i => Guid.NewGuid().ToString("N")).ToCommaDelimited() +
",localhost";
var zk = new ZooKeeper(connectionString, CONNECTION_TIMEOUT, NullWatcher.Instance);
await zk.existsAsync("/");
await zk.closeAsync();
log.debug("END - testOnlyOneAvailable");
}
/**
* Make sure all the nodes in the path are created. NOTE: Unlike File.mkdirs(), Zookeeper doesn't distinguish
* between directories and files. So, every node in the path is created. The data for each node is an empty blob
*
* @param zookeeper the client
* @param path path to ensure
* @param makeLastNode if true, all nodes are created. If false, only the parent nodes are created
* @param aclProvider if not null, the ACL provider to use when creating parent nodes
* @param asContainers if true, nodes are created as {@link CreateMode#CONTAINER}
* @throws InterruptedException thread interruption
* @throws org.apache.zookeeper.KeeperException Zookeeper errors
*/
public static async void mkdirs(ZooKeeper zookeeper,
String path,
bool makeLastNode,
IInternalACLProvider aclProvider,
bool asContainers)
{
PathUtils.validatePath(path);
int pos = 1; // skip first slash, root is guaranteed to exist
do
{
pos = path.IndexOf(PATH_SEPARATOR, pos + 1);
if ( pos == -1 )
{
if ( makeLastNode )
{
pos = path.Length;
}
else
{
break;
}
}
String subPath = path.Substring(0, pos);
if ( await zookeeper.existsAsync(subPath, false) == null )
{
try
{
IList<ACL> acl = null;
if ( aclProvider != null )
{
acl = aclProvider.getAclForPath(subPath);
if ( acl == null )
{
acl = aclProvider.getDefaultAcl();
}
}
if ( acl == null )
{
acl = ZooDefs.Ids.OPEN_ACL_UNSAFE;
}
await zookeeper.createAsync(subPath,
new byte[0],
acl.ToList(),
getCreateMode(asContainers))
.ConfigureAwait(false);
}
catch ( KeeperException.NodeExistsException)
{
// ignore... someone else has created it since we checked
}
}
}
while ( pos<path.Length );
}