public async Task TestZKLeaderSeletor1()
{
LOG.Info("------------ BEFORE -------------");
using (_zkClient = new ZKClient(TestUtil.zkServers))
{
await TestUtil.ReSetPathUnCreate(_zkClient, leaderPath);
var msgList = new List <string>();
await _zkClient.CreateRecursiveAsync(leaderPath, null, CreateMode.PERSISTENT);
var listener = new ZKLeaderSelectorListener();
listener.takeLeadership = async(client, selector) =>
{
try
{
await Task.Delay(1000);
}
catch (ThreadInterruptedException)
{
}
msgList.Add("server1 I am the leader");
Console.WriteLine("server1: I am the leader-" + await selector.GetLeaderAsync());
};
var selector1 = new ZKLeaderSelector("server1", true, _zkClient, leaderPath, listener);
var task = new Task(() =>
{
var zkClient1 = ZKClientBuilder.NewZKClient()
.Servers(TestUtil.zkServers)
.SessionTimeout(10000)
.Build();
var listener2 = new ZKLeaderSelectorListener();
listener2.takeLeadership = async(client, selector) =>
{
try
{
await Task.Delay(1000);
}
catch (ThreadInterruptedException)
{
}
msgList.Add("server2 I am the leader");
Console.WriteLine("server2: I am the leader-" + await selector.GetLeaderAsync());
selector.Close();
};
var selector2 = new ZKLeaderSelector("server2", true, zkClient1, leaderPath, listener2);
selector2.Start();
});
selector1.Start();
task.Start();
Thread.Sleep(1000);
int size = TestUtil.WaitUntil(2, () => { return(msgList.Count); }, new TimeSpan(0, 0, 100));
Assert.True(size == 2);
}
}
public void SubscribeChildChanges()
{
using (ZKClient zkClient = ZKClientBuilder.NewZKClient(TestUtil.zkServers).Build())
{
IZKChildListener childListener = new ZKChildListener();
//子节点内容变化
childListener.ChildChangeHandler = async(parentPath, currentChilds) =>
{
await Task.Run(() =>
{
Console.WriteLine(parentPath);
Console.WriteLine(string.Join(".", currentChilds));
});
};
//子节点数量变化
childListener.ChildCountChangedHandler = async(parentPath, currentChilds) =>
{
await Task.Run(() =>
{
Console.WriteLine(parentPath);
Console.WriteLine(string.Join(".", currentChilds));
});
};
//"/testUserNode" 监听的节点，可以是现在存在的也可以是不存在的
zkClient.SubscribeChildChanges("/testUserNode3", childListener);
Thread.Sleep(TimeSpan.FromSeconds(60));
}
}
/// <summary>
/// 创建Leader选举对象
/// </summary>
/// <param name="id">每个Leader选举的参与者都有一个ID标识，用于区分各个参与者。</param>
/// <param name="autoRequue">是否在由于网络问题造成与服务器断开连接后，自动参与到选举队列中。</param>
/// <param name="delayTimeMillis">延迟选举的时间，主要是针对网络闪断的情况，给Leader以重连并继续成为Leader的机会，一般5秒合适。</param>
/// <param name="client">ZKClient</param>
/// <param name="leaderPath">选举的路径</param>
/// <param name="listener">成为Leader后执行的的监听器</param>
public ZKLeaderDelySelector(string id, bool autoRequue, int delayTimeMillis, ZKClient client, string leaderPath, ZKLeaderSelectorListener listener)
{
this.delayTimeMillis = delayTimeMillis;
this.id = id;
this.client = client;
this.autoRequeue = autoRequue;
this.leaderPath = leaderPath;
this._lock = ZKDistributedDelayLock.NewInstance(client, leaderPath);
this._lock.SetLockNodeData(this.id);
this.listener = listener;
SetFactory();
stateListener = new ZKStateListener().StateChanged(
(state) =>
{
if (state == KeeperState.SyncConnected)
{
//如果重新连接
if (!isInterrupted)
{
Requeue();
}
}
});
}
public void CreateSession()
{
using (ZKClient zkClient = ZKClientBuilder.NewZKClient(TestUtil.zkServers).Build())
{
Console.WriteLine("conneted ok!");
}
}
public void SetUp()
{
zkConn = new StateOnlyConnection();
client = new ZKClient(zkConn);
listener = new TestStateListener();
client.SubscribeStateChanges(listener);
}
private ZKHALock(ZKClient client, string lockPach)
{
this.client = client;
this.lockPath = lockPach;
countListener = new ZKChildListener().ChildChange(
(parentPath, currentChilds) =>
{
if (Check(currentSeq, currentChilds))
{
semaphore.Release();
}
});
stateListener = new ZKStateListener().StateChanged(
(state) =>
{
if (state == KeeperState.SyncConnected)
{
//如果重新连接
//如果重连后之前的节点已删除，并且lock处于等待状态，则重新创建节点，等待获得lock
if (!client.Exists(lockPach + "/" + currentSeq) && !semaphore.WaitOne(1000))
{
string newPath = client.Create(lockPath + "/1", null, CreateMode.EphemeralSequential);
string[] paths = newPath.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
currentSeq = paths[paths.Length - 1];
}
}
});
}
public async Task TestZKLeaderSeletor()
{
LOG.Info("------------ BEFORE -------------");
using (_zkClient = new ZKClient(TestUtil.zkServers))
{
await TestUtil.ReSetPathUnCreate(_zkClient, leaderPath);
var msgList = new List <string>();
var count = new CountdownEvent(20);
var count1 = new CountdownEvent(20);
await _zkClient.CreateRecursiveAsync(leaderPath, null, CreateMode.PERSISTENT);
var index = 0;
for (int i = 0; i < 20; i++)
{
var name = "server:" + index;
var task = new Task(() =>
{
var zkClient1 = new ZKClient(TestUtil.zkServers);
var listener = new ZKLeaderSelectorListener();
listener.takeLeadership = async(client, selector) =>
{
msgList.Add(name + " I am the leader");
Console.WriteLine(name + ": I am the leader-" + await selector.GetLeaderAsync());
selector.Close();
count1.Signal();
};
var _selector = new ZKLeaderSelector(name, true, zkClient1, leaderPath, listener);
try
{
Console.WriteLine(name + ":waiting");
count.Wait();
}
//catch (ThreadInterruptedException)
catch (Exception)
{
}
_selector.Start();
try
{
count1.Wait();
}
//catch (ThreadInterruptedException)
catch (Exception)
{
}
});
task.Start();
count.Signal();
Interlocked.Increment(ref index);
}
int size = TestUtil.WaitUntil(20, () => { return(msgList.Count); }, new TimeSpan(0, 0, 100));
Assert.True(size == 20);
}
LOG.Info("------------ AFTER -------------");
}
public void TestZKLeaderSeletor()
{
List <string> msgList = new List <string>();
CountdownEvent count = new CountdownEvent(20);
CountdownEvent count1 = new CountdownEvent(20);
_zkClient.CreateRecursive(leaderPath, null, CreateMode.Persistent);
int index = 0;
for (int i = 0; i < 20; i++)
{
string name = "server:" + index;
Task task = new Task(() =>
{
ZKClient zkClient1 = ZKClientBuilder.NewZKClient()
.Servers(string.Format("{0}:{1}", TestUtil.ip, TestUtil.port))
.SessionTimeout(10000)
.Build();
ZKLeaderSelectorListener listener = new ZKLeaderSelectorListener()
.TakeLeadership((client, selector) =>
{
msgList.Add(name + " I am the leader");
Console.WriteLine(name + ": I am the leader-" + selector.GetLeader());
selector.Close();
count1.Signal();
});
ZKLeaderSelector _selector = new ZKLeaderSelector(name, true, zkClient1, leaderPath, listener);
try
{
Console.WriteLine(name + ":waiting");
count.Wait();
}
catch (ThreadInterruptedException e1)
{
}
_selector.Start();
try
{
count1.Wait();
}
catch (ThreadInterruptedException e)
{
}
});
task.Start();
count.Signal();
Interlocked.Increment(ref index);
}
int size = TestUtil.WaitUntil(20, () => { return(msgList.Count); }, new TimeSpan(0, 0, 100));
Assert.True(size == 20);
}
public void SetUp()
{
LOG.Info("------------ BEFORE -------------");
_zkClient = new ZKClient(new InMemoryConnection());
TestUtil.ReSetPathUnCreate(_zkClient, "/a");
TestUtil.ReSetPathUnCreate(_zkClient, "/a/a");
TestUtil.ReSetPathUnCreate(_zkClient, "/a/a/a");
TestUtil.ReSetPathUnCreate(_zkClient, "/gaga");
}
public ContentWatcher(ZKClient zkClient, string fileName)
{
_fileName = fileName;
_zkClient = zkClient;
dataListener.DataCreatedOrChangeHandler = async(dataPath, data) =>
{
await Task.Run(() => SetContent((T)data));
};
}
public virtual void SetUp()
{
LOG.Info("------------ BEFORE -------------");
_zkClient = ZKClientBuilder.NewZKClient()
.Servers(string.Format("{0}:{1}", TestUtil.ip, TestUtil.port))
.SessionTimeout(10000)
.Build();
TestUtil.ReSetPathUnCreate(_zkClient, leaderPath);
}
public void TestZKLeaderSeletor1()
{
List <string> msgList = new List <string>();
_zkClient.CreateRecursive(leaderPath, null, CreateMode.Persistent);
ZKLeaderSelectorListener listener = new ZKLeaderSelectorListener()
.TakeLeadership((client, selector) =>
{
try
{
Thread.Sleep(1000);
}
catch (ThreadInterruptedException e)
{
}
msgList.Add("server1 I am the leader");
Console.WriteLine("server1: I am the leader-" + selector.GetLeader());
});
ZKLeaderSelector selector1 = new ZKLeaderSelector("server1", true, _zkClient, leaderPath, listener);
Task task = new Task(() =>
{
ZKClient zkClient1 = ZKClientBuilder.NewZKClient()
.Servers(string.Format("{0}:{1}", TestUtil.ip, TestUtil.port))
.SessionTimeout(10000)
.Build();
ZKLeaderSelectorListener listener2 = new ZKLeaderSelectorListener()
.TakeLeadership((client, selector) =>
{
try
{
Thread.Sleep(1000);
}
catch (ThreadInterruptedException e)
{
}
msgList.Add("server2 I am the leader");
Console.WriteLine("server2: I am the leader-" + selector.GetLeader());
selector.Close();
});
ZKLeaderSelector selector2 = new ZKLeaderSelector("server2", true, zkClient1, leaderPath, listener2);
selector2.Start();
});
selector1.Start();
task.Start();
Thread.Sleep(1000);
int size = TestUtil.WaitUntil(2, () => { return(msgList.Count); }, new TimeSpan(0, 0, 100));
Assert.True(size == 2);
}
public async Task GetData()
{
using (ZKClient zkClient = ZKClientBuilder.NewZKClient(TestUtil.zkServers).Build())
{
//获取 节点中的对象
User user = await zkClient.GetDataAsync <User>("/testUserNode");
Console.WriteLine(user.Name);
}
}
public async Task Exists()
{
using (ZKClient zkClient = ZKClientBuilder.NewZKClient(TestUtil.zkServers).Build())
{
bool e = await zkClient.ExistsAsync("/testUserNode");
//返回 true表示节点存在 ，false表示不存在
Console.WriteLine(e);
}
}
public void CreateSession()
{
ZKClient zkClient = ZKClientBuilder.NewZKClient(TestUtil.zkServers)
.SessionTimeout(10000)
.ConnectionTimeout(10000)
.Serializer(new SerializableSerializer())
.Build();
Console.WriteLine("conneted ok!");
zkClient.Close();
zkClient = null;
}
public async Task TestSerializables()
{
using (ZKClient _zkClient = new ZKClient(TestUtil.zkServers))
{
await TestUtil.ReSetPathUnCreate(_zkClient, "/a");
string data = "hello world";
await _zkClient.CreatePersistentAsync("/a", data);
string readData = await _zkClient.GetDataAsync <string>("/a");
}
}
public void TestBytes()
{
ZKClient _zkClient = new ZKClient(string.Format("{0}:{1}", TestUtil.ip, TestUtil.port), new TimeSpan(0, 0, 0, 0, 2000), new TimeSpan(0, 0, 0, 0, 3000), new BytesPushThroughSerializer());
TestUtil.ReSetPathUnCreate(_zkClient, "/a");
byte[] bytes = new byte[100];
new Random().NextBytes(bytes);
_zkClient.CreatePersistent("/a", bytes);
byte[] readBytes = _zkClient.ReadData <byte[]>("/a");
_zkClient.Close();
_zkClient = null;
}
public async Task SetData()
{
using (ZKClient zkClient = ZKClientBuilder.NewZKClient(TestUtil.zkServers).Build())
{
User user = new User();
user.Id = 2;
user.Name = "testUser2";
//testUserNode 节点的路径
//user 传入的数据对象
await zkClient.SetDataAsync <User>("/testUserNode", user);
}
}
/// <summary>
/// 创建分布式锁实例的工厂方法
/// </summary>
/// <param name="client"></param>
/// <param name="lockPach"></param>
/// <returns></returns>
public static ZKDistributedLock NewInstance(ZKClient client, string lockPach)
{
if (!client.Exists(lockPach))
{
throw new ZKNoNodeException("The lockPath is not exists!,please create the node.[path:" + lockPach + "]");
}
ZKDistributedLock zkDistributedLock = new ZKDistributedLock(client, lockPach);
//对lockPath进行子节点数量的监听
client.SubscribeChildChanges(lockPach, zkDistributedLock.countListener);
return(zkDistributedLock);
}
public static void ReSetPathCreate(ZKClient _zkClient, string path)
{
if (!_zkClient.Exists(path))
{
_zkClient.CreatePersistent(path);
}
else
{
_zkClient.DeleteRecursive(path);
_zkClient.CreatePersistent(path);
}
}
public void TestSerializables()
{
ZKClient _zkClient = new ZKClient(string.Format("{0}:{1}", TestUtil.ip, TestUtil.port), new TimeSpan(0, 0, 0, 0, 2000), new TimeSpan(0, 0, 0, 0, 3000), new SerializableSerializer());
TestUtil.ReSetPathUnCreate(_zkClient, "/a");
string data = "hello world";
_zkClient.CreatePersistent("/a", data);
string readData = _zkClient.ReadData <string>("/a");
_zkClient.Close();
_zkClient = null;
}
public async Task TestBytes()
{
using (ZKClient _zkClient = new ZKClient(TestUtil.zkServers))
{
await TestUtil.ReSetPathUnCreate(_zkClient, "/a");
byte[] bytes = new byte[100];
new Random().NextBytes(bytes);
await _zkClient.CreatePersistentAsync("/a", bytes);
byte[] readBytes = await _zkClient.GetDataAsync <byte[]>("/a");
}
}
public static void ReSetPathUnCreate(ZKClient _zkClient, string path)
{
var children = _zkClient.GetChildren("/");
children.ForEach(x =>
{
_zkClient.DeleteRecursive("/" + x);
});
if (_zkClient.Exists(path))
{
_zkClient.DeleteRecursive(path);
}
}
public ZookeeperRegistryService(IOptions <ZookeeperOption> options, ILoggerFactory loggerFactory) : base(loggerFactory)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
this.Options = options.Value;
configClient = ZKClientBuilder.NewZKClient(this.Options.ConnectString)
.SessionTimeout(this.Options.SessionTimeout) //可选
.ConnectionTimeout(this.Options.ConnectionTimeout) //可选
.Build(); //创建实例
}
public static async Task ReSetPathUnCreate(ZKClient _zkClient, string path)
{
var children = await _zkClient.GetChildrenAsync("/");
children.Where(x => x != "zookeeper").ToList().ForEach(async x =>
{
await _zkClient.DeleteRecursiveAsync("/" + x);
});
if (await _zkClient.ExistsAsync(path))
{
await _zkClient.DeleteRecursiveAsync(path);
}
}
public static async Task ReSetPathCreate(ZKClient _zkClient, string path)
{
if (!(await _zkClient.ExistsAsync(path)))
{
await _zkClient.CreatePersistentAsync(path);
}
else
{
await _zkClient.DeleteRecursiveAsync(path);
await _zkClient.CreatePersistentAsync(path);
}
}
public async Task Delete()
{
using (ZKClient zkClient = ZKClientBuilder.NewZKClient(TestUtil.zkServers).Build())
{
//删除单独一个节点，返回true表示成功
bool e1 = await zkClient.DeleteAsync("/testUserNode");
//删除含有子节点的节点
bool e2 = await zkClient.DeleteRecursiveAsync("/test");
//返回 true表示节点成功 ，false表示删除失败
Console.WriteLine(e1);
Console.WriteLine(e2);
}
}
public async Task CreateNode()
{
using (ZKClient zkClient = ZKClientBuilder.NewZKClient(TestUtil.zkServers).Build())
{
User user = new User();
user.Id = 1;
user.Name = "testUser";
await zkClient.DeleteRecursiveAsync("/testUserNode");
var path = await zkClient.CreateAsync("/testUserNode", user, CreateMode.PERSISTENT);
//输出创建节点的路径
Console.WriteLine("created path:" + path);
}
}
private ZKDistributedLock(ZKClient client, string lockPach)
{
this.client = client;
this.lockPath = lockPach;
IZKChildListener childListener = new ZKChildListener().ChildChange(
(parentPath, currentChilds) =>
{
if (Check(currentSeq, currentChilds))
{
semaphore.Release();
}
});
this.countListener = childListener;
}
public async Task TestMultipleReadingThreads()
{
using (_zkClient = new ZKClient(TestUtil.zkServers))
{
await TestUtil.ReSetPathUnCreate(_zkClient, queuePath);
await _zkClient.CreateRecursiveAsync(queuePath, null, CreateMode.PERSISTENT);
var queue = new ZKDistributedQueue <long>(_zkClient, queuePath);
// insert 100 elements
for (int i = 0; i < 100; i++)
{
await queue.OfferAsync(i);
}
// 3 reading threads
ConcurrentHashSet <long?> readElements = new ConcurrentHashSet <long?>();
var tasks = new Task[3];
List <Exception> exceptions = new List <Exception>();
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = Task.Run(async() =>
{
try
{
while (true)
{
long?value = await queue.PollAsync();
if (!value.HasValue)
{
return;
}
readElements.Add(value);
}
}
catch (Exception e)
{
exceptions.Add(e);
}
});
}
Task.WaitAll(tasks);
Assert.True((0 == exceptions.Count));
Assert.True((100 == readElements.Count));
}
}
