/// <exception cref="System.IO.IOException"/>
public virtual RegistryPathStatus Stat(string path)
{
ValidatePath(path);
Org.Apache.Zookeeper.Data.Stat stat = ZkStat(path);
string name = RegistryPathUtils.LastPathEntry(path);
RegistryPathStatus status = new RegistryPathStatus(name, stat.GetCtime(), stat.GetDataLength
(), stat.GetNumChildren());
if (Log.IsDebugEnabled())
{
Log.Debug("Stat {} => {}", path, status);
}
return(status);
}
public void ProcessResult(KeeperException.Code rc, String path, Object ctx, Stat stat)
{
bool exists;
switch (rc)
{
case KeeperException.Code.OK:
exists = true;
break;
case KeeperException.Code.NONODE:
exists = false;
break;
case KeeperException.Code.SESSIONEXPIRED:
case KeeperException.Code.NOAUTH:
Dead = true;
_listener.Closing(rc);
return;
default:
// Retry errors
_zk.Exists(_znode, true);
return;
}
byte[] b = null;
if (exists)
{
try
{
b = _zk.GetData(_znode, false, null);
}
catch (KeeperException e)
{
// We don't need to worry about recovering now. The watch
// callbacks will kick off any exception handling
//TODO
}
catch (Exception e)
{
return;
}
}
if ((b == null && b != _prevData)
|| (b != null && !Equals(_prevData, b)))
{
_listener.Exists(b);
_prevData = b;
}
}
private string GetLeader()
{
try
{
var stat = new Org.Apache.Zookeeper.Data.Stat();
var b = zooKeeper.GetData("/overseer/leader", false, stat);
if (b != null)
{
return(Encoding.UTF8.GetString(b));
}
}
catch (Exception ex)
{
Logger.GetLogger(BaseUrl).Error(BaseUrl + " read leader failed!" + ex.Message);
}
return(null);
}
protected string GetLeader()
{
try
{
var stat = new Org.Apache.Zookeeper.Data.Stat();
var b = zooKeeper.GetData("/overseer/leader", false, stat);
if (b != null)
{
return(Encoding.UTF8.GetString(b));
}
}
catch (Exception ex)
{
Console.WriteLine(BaseUrl + " read leader failed!");
}
return(null);
}
private static bool checkMaster(ZooKeeper zk)
{
while (true)
{
try
{
Stat stat = new Stat();
byte[] data = zk.GetData("/master", false, stat);
var isLeader = System.Text.Encoding.UTF8.GetString(data).Equals("230");
return true;
}
catch (KeeperException.NoNodeException)
{
return false;
}
catch (Exception ex)
{
return false;
}
}
}
public void testChild()
{
string name = "/" + Guid.NewGuid() + "foo";
zk.Create(name, name.GetBytes(), Ids.OPEN_ACL_UNSAFE,
CreateMode.Persistent);
string childname = name + "/bar";
zk.Create(childname, childname.GetBytes(), Ids.OPEN_ACL_UNSAFE,
CreateMode.Ephemeral);
Stat stat = new Stat();
List<string> s = zk.GetChildren(name, false, stat);
Assert.AreEqual(stat.Czxid, stat.Mzxid);
Assert.AreEqual(stat.Czxid + 1, stat.Pzxid);
Assert.AreEqual(stat.Ctime, stat.Mtime);
Assert.AreEqual(1, stat.Cversion);
Assert.AreEqual(0, stat.Version);
Assert.AreEqual(0, stat.Aversion);
Assert.AreEqual(0, stat.EphemeralOwner);
Assert.AreEqual(name.Length, stat.DataLength);
Assert.AreEqual(1, stat.NumChildren);
Assert.AreEqual(s.Count, stat.NumChildren);
s = zk.GetChildren(childname, false, stat);
Assert.AreEqual(stat.Czxid, stat.Mzxid);
Assert.AreEqual(stat.Czxid, stat.Pzxid);
Assert.AreEqual(stat.Ctime, stat.Mtime);
Assert.AreEqual(0, stat.Cversion);
Assert.AreEqual(0, stat.Version);
Assert.AreEqual(0, stat.Aversion);
Assert.AreEqual(zk.SessionId, stat.EphemeralOwner);
Assert.AreEqual(childname.Length, stat.DataLength);
Assert.AreEqual(0, stat.NumChildren);
Assert.AreEqual(s.Count, stat.NumChildren);
}
/// <summary>
/// Fetches data from a given path in ZooKeeper
/// </summary>
/// <param name="path">
/// The given path.
/// </param>
/// <param name="stats">
/// The statistics.
/// </param>
/// <param name="watch">
/// Indicates whether should reinstall watcher in ZooKeeper.
/// </param>
/// <returns>
/// Data
/// </returns>
public byte[] ReadData(string path, Stat stats, bool watch)
{
Guard.Assert<ArgumentException>(() => !string.IsNullOrEmpty(path));
this.EnsuresNotDisposed();
return this.Client.GetData(path, watch, stats);
}
public void testMutipleWatcherObjs()
{
ZooKeeper zk = CreateClient(new CountdownWatcher());
try
{
MyWatcher[] watchers = new MyWatcher[100];
MyWatcher[] watchers2 = new MyWatcher[watchers.Length];
string name = "/" + Guid.NewGuid() + "foo-";
for (int i = 0; i < watchers.Length; i++)
{
watchers[i] = new MyWatcher();
watchers2[i] = new MyWatcher();
zk.Create(name + i, ("foodata" + i).GetBytes(),
Ids.OPEN_ACL_UNSAFE, CreateMode.Persistent);
}
Stat stat = new Stat();
//
// test get/Exists with single set of watchers
// get all, then Exists all
//
for (int i = 0; i < watchers.Length; i++)
{
Assert.NotNull(zk.GetData(name + i, watchers[i], stat));
}
for (int i = 0; i < watchers.Length; i++)
{
Assert.NotNull(zk.Exists(name + i, watchers[i]));
}
// trigger the watches
for (int i = 0; i < watchers.Length; i++)
{
zk.SetData(name + i, ("foodata2-" + i).GetBytes(), -1);
zk.SetData(name + i, ("foodata3-" + i).GetBytes(), -1);
}
for (int i = 0; i < watchers.Length; i++)
{
WatchedEvent @event;
watchers[i].events.TryTake(out @event, TimeSpan.FromSeconds(3d));
Assert.AreEqual(name + i, @event.Path);
Assert.AreEqual(EventType.NodeDataChanged, @event.Type);
Assert.AreEqual(KeeperState.SyncConnected, @event.State);
// small chance that an unexpected message was delivered
// after this check, but we would catch that next time
// we check events
Assert.AreEqual(0, watchers[i].events.Count);
}
//
// test get/Exists with single set of watchers
// get/Exists together
//
for (int i = 0; i < watchers.Length; i++)
{
Assert.NotNull(zk.GetData(name + i, watchers[i], stat));
Assert.NotNull(zk.Exists(name + i, watchers[i]));
}
// trigger the watches
for (int i = 0; i < watchers.Length; i++)
{
zk.SetData(name + i, ("foodata4-" + i).GetBytes(), -1);
zk.SetData(name + i, ("foodata5-" + i).GetBytes(), -1);
}
for (int i = 0; i < watchers.Length; i++)
{
WatchedEvent @event;
watchers[i].events.TryTake(out @event, TimeSpan.FromSeconds(10d));
Assert.AreEqual(name + i, @event.Path);
Assert.AreEqual(EventType.NodeDataChanged, @event.Type);
Assert.AreEqual(KeeperState.SyncConnected, @event.State);
// small chance that an unexpected message was delivered
// after this check, but we would catch that next time
// we check events
Assert.AreEqual(0, watchers[i].events.Count);
}
//
// test get/Exists with two sets of watchers
//
for (int i = 0; i < watchers.Length; i++)
{
Assert.NotNull(zk.GetData(name + i, watchers[i], stat));
Assert.NotNull(zk.Exists(name + i, watchers2[i]));
}
// trigger the watches
for (int i = 0; i < watchers.Length; i++)
{
zk.SetData(name + i, ("foodata6-" + i).GetBytes(), -1);
zk.SetData(name + i, ("foodata7-" + i).GetBytes(), -1);
}
for (int i = 0; i < watchers.Length; i++)
{
WatchedEvent @event;
watchers[i].events.TryTake(out @event, TimeSpan.FromSeconds(3000));
Assert.AreEqual(name + i, @event.Path);
Assert.AreEqual(EventType.NodeDataChanged, @event.Type);
Assert.AreEqual(KeeperState.SyncConnected, @event.State);
// small chance that an unexpected message was delivered
// after this check, but we would catch that next time
// we check events
Assert.AreEqual(0, watchers[i].events.Count);
// watchers2
WatchedEvent event2;
watchers2[i].events.TryTake(out @event2, TimeSpan.FromSeconds(3000));
Assert.AreEqual(name + i, event2.Path);
Assert.AreEqual(EventType.NodeDataChanged, event2.Type);
Assert.AreEqual(KeeperState.SyncConnected, event2.State);
// small chance that an unexpected message was delivered
// after this check, but we would catch that next time
// we check events
Assert.AreEqual(0, watchers2[i].events.Count);
}
}
finally
{
if (zk != null)
{
zk.Dispose();
}
}
}
public static void CopyStat(Stat from, Stat to)
{
to.Aversion = from.Aversion;
to.Ctime = from.Ctime;
to.Cversion = from.Cversion;
to.Czxid = from.Czxid;
to.Mtime = from.Mtime;
to.Mzxid = from.Mzxid;
to.Pzxid = from.Pzxid;
to.Version = from.Version;
to.EphemeralOwner = from.EphemeralOwner;
to.DataLength = from.DataLength;
to.NumChildren = from.NumChildren;
}
public void CopyStat(Stat to)
{
try
{
SpinWait.SpinUntil(() => Interlocked.CompareExchange(ref lockedInt, 1, 0) == 0);
to.Aversion = stat.Aversion;
to.Ctime = stat.Ctime;
to.Cversion = stat.Cversion;
to.Czxid = stat.Czxid;
to.Mtime = stat.Mtime;
to.Mzxid = stat.Mzxid;
to.Pzxid = stat.Pzxid;
to.Version = stat.Version;
to.EphemeralOwner = stat.EphemeralOwner;
to.DataLength = data == null ? 0 : data.Length;
if (this.children == null)
{
to.NumChildren = 0;
}
else
{
to.NumChildren = children.Count;
}
}
finally
{
Interlocked.Exchange(ref lockedInt, 0);
}
}
public GetDataResponse(byte[] data, Org.Apache.Zookeeper.Data.Stat stat)
{
this.Data = data;
this.Stat = stat;
}
public SetDataResponse(Org.Apache.Zookeeper.Data.Stat stat)
{
this.Stat = stat;
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
Stat peer = (Stat)obj;
if (peer == null)
{
return(false);
}
if (ReferenceEquals(peer, this))
{
return(true);
}
bool ret = false;
ret = (Czxid == peer.Czxid);
if (!ret)
{
return(ret);
}
ret = (Mzxid == peer.Mzxid);
if (!ret)
{
return(ret);
}
ret = (Ctime == peer.Ctime);
if (!ret)
{
return(ret);
}
ret = (Mtime == peer.Mtime);
if (!ret)
{
return(ret);
}
ret = (Version == peer.Version);
if (!ret)
{
return(ret);
}
ret = (Cversion == peer.Cversion);
if (!ret)
{
return(ret);
}
ret = (Aversion == peer.Aversion);
if (!ret)
{
return(ret);
}
ret = (EphemeralOwner == peer.EphemeralOwner);
if (!ret)
{
return(ret);
}
ret = (DataLength == peer.DataLength);
if (!ret)
{
return(ret);
}
ret = (NumChildren == peer.NumChildren);
if (!ret)
{
return(ret);
}
ret = (Pzxid == peer.Pzxid);
if (!ret)
{
return(ret);
}
return(ret);
}
public void testChildren()
{
string name = "/" + Guid.NewGuid() + "foo";
zk.Create(name, name.GetBytes(), Ids.OPEN_ACL_UNSAFE,
CreateMode.Persistent);
List<string> children = new List<string>();
List<string> children_s = new List<string>();
for (int i = 0; i < 10; i++)
{
string childname = name + "/bar" + i;
string childname_s = "bar" + i;
children.Add(childname);
children_s.Add(childname_s);
}
for (int i = 0; i < children.Count; i++)
{
string childname = children[i];
zk.Create(childname, childname.GetBytes(), Ids.OPEN_ACL_UNSAFE,
CreateMode.Ephemeral);
Stat stat = new Stat();
List<string> s = zk.GetChildren(name, false, stat);
Assert.AreEqual(stat.Czxid, stat.Mzxid);
Assert.AreEqual(stat.Czxid + i + 1, stat.Pzxid);
Assert.AreEqual(stat.Ctime, stat.Mtime);
Assert.AreEqual(i + 1, stat.Cversion);
Assert.AreEqual(0, stat.Version);
Assert.AreEqual(0, stat.Aversion);
Assert.AreEqual(0, stat.EphemeralOwner);
Assert.AreEqual(name.Length, stat.DataLength);
Assert.AreEqual(i + 1, stat.NumChildren);
Assert.AreEqual(s.Count, stat.NumChildren);
}
List<string> p = zk.GetChildren(name, false, null);
List<string> c_a = children_s;
List<string> c_b = p;
c_a = c_a.OrderBy(e => e).ToList();
c_b = c_b.OrderBy(e => e).ToList();
Assert.AreEqual(c_a.Count, 10);
Assert.AreEqual(c_a, c_b);
}
public byte[] ReadData(string path, Stat stat, bool watch)
{
return this._zk.GetData(path, watch, stat);
}
public ExistsResponse(Org.Apache.Zookeeper.Data.Stat stat)
{
this.Stat = stat;
}
public static Tuple<string, Stat> ReadData(ZkClient client, string path)
{
var stat = new Stat();
var dataString = client.ReadData<string>(path, stat);
return Tuple.Create(dataString, stat);
}
/// <summary>
/// Fetches data from a given path in ZooKeeper
/// </summary>
/// <param name="path">
/// The given path.
/// </param>
/// <param name="stats">
/// The statistics.
/// </param>
/// <param name="watch">
/// Indicates whether should reinstall watcher in ZooKeeper.
/// </param>
/// <returns>
/// Data
/// </returns>
public byte[] ReadData(string path, Stat stats, bool watch)
{
Guard.NotNullNorEmpty(path, "path");
this.EnsuresNotDisposed();
return this.Client.GetData(path, watch, stats);
}
public ZookeeperContentReader(Stat stat, byte[] data)
{
this._stat = stat;
this._data = new MemoryStream(data);
}
public GetACLResponse(IEnumerable <ACL> acl, Org.Apache.Zookeeper.Data.Stat stat)
{
this.Acl = acl;
this.Stat = stat;
}
public void CopyStat(Stat to)
{
lock (locker)
{
to.Aversion = stat.Aversion;
to.Ctime = stat.Ctime;
to.Cversion = stat.Cversion;
to.Czxid = stat.Czxid;
to.Mtime = stat.Mtime;
to.Mzxid = stat.Mzxid;
to.Pzxid = stat.Pzxid;
to.Version = stat.Version;
to.EphemeralOwner = stat.EphemeralOwner;
to.DataLength = data == null ? 0 : data.Length;
if (this.children == null)
{
to.NumChildren = 0;
}
else
{
to.NumChildren = children.Count;
}
}
}
public static Tuple<string, Stat> ReadDataMaybeNull(ZkClient client, string path)
{
var stat = new Stat();
try
{
var obj = client.ReadData<string>(path, stat);
return Tuple.Create(obj, stat);
}
catch (ZkNoNodeException)
{
return Tuple.Create((string)null, stat);
}
}
private void performClientTest(bool withWatcherObj)
{
MyWatcher watcher = new MyWatcher();
using (var zk = CreateClient(watcher))
{
LOG.Info("Before Create /benwashere");
string benwashere = "/" + Guid.NewGuid() + "benwashere";
zk.Create(benwashere, "".GetBytes(), Ids.OPEN_ACL_UNSAFE,
CreateMode.Persistent);
LOG.Info("After Create /benwashere");
try
{
zk.SetData(benwashere, "hi".GetBytes(), 57);
Assert.Fail("Should have gotten BadVersion exception");
}
catch (KeeperException.BadVersionException e)
{
// expected that
}
catch (KeeperException e)
{
Assert.Fail("Should have gotten BadVersion exception");
}
LOG.Info("Before Delete /benwashere");
zk.Delete(benwashere, 0);
LOG.Info("After Delete /benwashere");
}
//LOG.Info("Closed client: " + zk.describeCNXN());
Thread.Sleep(2000);
using (var zk = CreateClient(watcher))
{
//LOG.Info("Created a new client: " + zk.describeCNXN());
LOG.Info("Before Delete /");
try
{
zk.Delete("/", -1);
Assert.Fail("Deleted root!");
}
catch (KeeperException.BadArgumentsException e)
{
// good, expected that
}
Stat stat = new Stat();
// Test basic Create, ls, and GetData
string pat = "/pat" + Guid.NewGuid();
string patPlusBen = pat + "/ben";
zk.Create(pat, "Pat was here".GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.Persistent);
LOG.Info("Before Create /ben");
zk.Create(patPlusBen, "Ben was here".GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.Persistent);
LOG.Info("Before GetChildren /pat");
List<string> children = zk.GetChildren(pat, false);
Assert.AreEqual(1, children.Count);
Assert.AreEqual("ben", children[0]);
List<string> children2 = zk.GetChildren(pat, false, null);
Assert.AreEqual(children, children2);
string value = Encoding.UTF8.GetString(zk.GetData(patPlusBen, false, stat));
Assert.AreEqual("Ben was here", value);
// Test stat and watch of non existent node
string frog = "/frog" + Guid.NewGuid();
try
{
if (withWatcherObj)
{
Assert.AreEqual(null, zk.Exists(frog, watcher));
}
else
{
Assert.AreEqual(null, zk.Exists(frog, true));
}
LOG.Info("Comment: asseting passed for frog setting /");
}
catch (KeeperException.NoNodeException e)
{
// OK, expected that
}
zk.Create(frog, "hi".GetBytes(), Ids.OPEN_ACL_UNSAFE,
CreateMode.Persistent);
// the first poll is just a session delivery
LOG.Info("Comment: checking for events Length "
+ watcher.events.Count);
WatchedEvent @event;
watcher.events.TryTake(out @event, TimeSpan.FromSeconds(3000));
Assert.AreEqual(frog, @event.Path);
Assert.AreEqual(EventType.NodeCreated, @event.Type);
Assert.AreEqual(KeeperState.SyncConnected, @event.State);
// Test child watch and Create with sequence
zk.GetChildren(patPlusBen, true);
for (int i = 0; i < 10; i++)
{
zk.Create(patPlusBen + "/" + i + "-", Convert.ToString(i).GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PersistentSequential);
}
children = zk.GetChildren(patPlusBen, false);
children = children.OrderBy(s => s).ToList();
Assert.AreEqual(10, children.Count);
for (int i = 0; i < 10; i++)
{
string name = children[i];
Assert.True(name.StartsWith(i + "-"), "starts with -");
byte[] b;
if (withWatcherObj)
{
b = zk.GetData(patPlusBen + "/" + name, watcher, stat);
}
else
{
b = zk.GetData(patPlusBen + "/" + name, true, stat);
}
Assert.AreEqual(Convert.ToString(i), Encoding.UTF8.GetString(b));
zk.SetData(patPlusBen + "/" + name, "new".GetBytes(),
stat.Version);
if (withWatcherObj)
{
stat = zk.Exists(patPlusBen + "/" + name, watcher);
}
else
{
stat = zk.Exists(patPlusBen + "/" + name, true);
}
zk.Delete(patPlusBen + "/" + name, stat.Version);
}
watcher.events.TryTake(out @event, TimeSpan.FromSeconds(3));
Assert.AreEqual(patPlusBen, @event.Path);
Assert.AreEqual(EventType.NodeChildrenChanged, @event.Type);
Assert.AreEqual(KeeperState.SyncConnected, @event.State);
for (int i = 0; i < 10; i++)
{
watcher.events.TryTake(out @event, TimeSpan.FromSeconds(3));
string name = children[i];
Assert.AreEqual(patPlusBen + "/" + name, @event.Path);
Assert.AreEqual(EventType.NodeDataChanged, @event.Type);
Assert.AreEqual(KeeperState.SyncConnected, @event.State);
watcher.events.TryTake(out @event, TimeSpan.FromSeconds(3));
Assert.AreEqual(patPlusBen + "/" + name, @event.Path);
Assert.AreEqual(EventType.NodeDeleted, @event.Type);
Assert.AreEqual(KeeperState.SyncConnected, @event.State);
}
zk.Create("/good" + Guid.NewGuid() + "\u0040path", "".GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.Persistent);
var dup = "/duplicate" + Guid.NewGuid();
zk.Create(dup, "".GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.Persistent);
try
{
zk.Create(dup, "".GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.Persistent);
Assert.Fail("duplicate Create allowed");
}
catch (KeeperException.NodeExistsException e)
{
// OK, expected that
}
}
}
/// <summary>
/// Fetches data from a given path in ZooKeeper
/// </summary>
/// <param name="path">
/// The given path.
/// </param>
/// <param name="stats">
/// The statistics.
/// </param>
/// <param name="watch">
/// Indicates whether should reinstall watcher in ZooKeeper.
/// </param>
/// <returns>
/// Data
/// </returns>
public byte[] ReadData(string path, Stat stats, bool watch)
{
Guard.NotNullNorEmpty(path, "path");
this.EnsuresNotDisposedAndNotNull();
var nodedata = this._zkclient.GetData(path, watch, stats);
return nodedata;
}
/**
* Create a new Stat, fill in dummy values trying to catch Assert.failure
* to copy in client or server code.
*
* @return a new stat with dummy values
*/
private Stat newStat()
{
Stat stat = new Stat();
stat.Aversion = 100;
stat.Ctime = 100;
stat.Cversion = 100;
stat.Czxid = 100;
stat.DataLength = 100;
stat.EphemeralOwner = 100;
stat.Mtime = 100;
stat.Mzxid = 100;
stat.NumChildren = 100;
stat.Pzxid = 100;
stat.Version = 100;
return stat;
}
public GetChildren2Response(IEnumerable <string> children, Org.Apache.Zookeeper.Data.Stat stat)
{
this.Children = children;
this.Stat = stat;
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public int CompareTo(object obj)
{
Stat peer = (Stat)obj;
if (peer == null)
{
throw new InvalidOperationException("Comparing different types of records.");
}
int ret = 0;
ret = (Czxid == peer.Czxid) ? 0 : ((Czxid < peer.Czxid) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
ret = (Mzxid == peer.Mzxid) ? 0 : ((Mzxid < peer.Mzxid) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
ret = (Ctime == peer.Ctime) ? 0 : ((Ctime < peer.Ctime) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
ret = (Mtime == peer.Mtime) ? 0 : ((Mtime < peer.Mtime) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
ret = (Version == peer.Version) ? 0 : ((Version < peer.Version) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
ret = (Cversion == peer.Cversion) ? 0 : ((Cversion < peer.Cversion) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
ret = (Aversion == peer.Aversion) ? 0 : ((Aversion < peer.Aversion) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
ret = (EphemeralOwner == peer.EphemeralOwner) ? 0 : ((EphemeralOwner < peer.EphemeralOwner) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
ret = (DataLength == peer.DataLength) ? 0 : ((DataLength < peer.DataLength) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
ret = (NumChildren == peer.NumChildren) ? 0 : ((NumChildren < peer.NumChildren) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
ret = (Pzxid == peer.Pzxid) ? 0 : ((Pzxid < peer.Pzxid) ? -1 : 1);
if (ret != 0)
{
return(ret);
}
return(ret);
}
