public NnsServer(string identity, int port, string standbyNode)
{
if (port <= 0 || port > short.MaxValue)
{
throw new ArgumentOutOfRangeException("The specified server listening port is outside the 0~65535 range");
}
if (string.IsNullOrEmpty(standbyNode))
{
throw new ArgumentOutOfRangeException("You have specified an invalid standby server host address that is not allowed to be null or empty");
}
if (string.IsNullOrEmpty(identity))
{
throw new ArgumentOutOfRangeException("You have specified an invalid node Identity");
}
this.malockListener = new MalockSocketListener(port);
this.nnsTable = new NnsTable();
do
{
this.onReceivedHandler = this.ProcessReceived;
this.onAboredHandler = this.ProcessAborted;
this.malockListener.Accept += (sender, e) =>
{
MalockSocket socket = (MalockSocket)e;
lock (socket)
{
socket.Received += this.onReceivedHandler;
socket.Aborted += this.onAboredHandler;
socket.Connected += this.onConnectedHandler;
socket.Run();
}
};
} while (false);
this.nnsStanbyClient = new NnsStanbyClient(this.nnsTable, identity, standbyNode, port);
this.onConnectedHandler = (sender, e) => this.ProcessAccept(sender, (MalockSocket)sender);
}
private void QueryHostEntry(MalockSocket socket, int sequence, string key)
{
string identity;
HostEntry entry = this.nnsTable.GetEntry(key, out identity);
MalockNnsMessage message = new MalockNnsMessage();
message.Key = key;
message.Sequence = sequence;
message.Command = MalockMessage.COMMON_COMMAND_ERROR;
if (entry != null)
{
message.Command = MalockNnsMessage.CLIENT_COMMAND_QUERYHOSTENTRYINFO;
}
using (MemoryStream stream = new MemoryStream())
{
using (BinaryWriter bw = new BinaryWriter(stream))
{
message.Serialize(bw);
if (entry != null)
{
entry.Serialize(bw);
}
MalockMessage.TrySendMessage(socket, stream);
}
}
this.PostSynHostEntryMessage(this.nnsStanbyClient, key, identity, entry);
}
private void SynQueryHostEntry(MalockSocket socket, string identity, string key, HostEntry entry)
{
if (entry == null || socket == null || string.IsNullOrEmpty(identity) || string.IsNullOrEmpty(key))
{
return;
}
lock (this.nnsTable.GetSynchronizationObject())
{
this.nnsTable.SetEntry(identity, key, entry);
}
}
private void ProcessClient(MalockSocket socket, MalockNnsMessage message)
{
if (message.Command == MalockNnsMessage.CLIENT_COMMAND_QUERYHOSTENTRYINFO)
{
this.QueryHostEntry(socket, message.Sequence, message.Key);
}
else if (message.Command == MalockNnsMessage.CLIENT_COMMAND_DUMPHOSTENTRYINFO)
{
this.DumpHostEntry(socket, message);
}
}
private void ProcessAborted(object sender, EventArgs e)
{
MalockSocket socket = (MalockSocket)sender;
if (socket.LinkMode == MalockMessage.LINK_MODE_SERVER)
{
this.AbortHostEntry(socket.Identity, socket.Address);
}
lock (socket)
{
socket.Aborted -= this.onAboredHandler;
socket.Connected -= this.onConnectedHandler;
socket.Received -= this.onReceivedHandler;
}
}
private void ProcessServer(MalockSocket socket, MalockNnsMessage message, Stream stream)
{
if (message.Command == MalockNnsMessage.SERVER_NNS_COMMAND_SYN_HOSTENTRYINFO)
{
this.SynQueryHostEntry(socket, message.Identity, message.Key, HostEntry.Deserialize(stream));
}
else if (message.Command == MalockNnsMessage.SERVER_NDN_COMMAND_REGISTERHOSTENTRYINFO)
{
this.RegisterHostEntry(socket, message.Sequence, HostEntry.Deserialize(stream));
}
else if (message.Command == MalockNnsMessage.SERVER_NNS_COMMAND_DUMPHOSTENTRYINFO)
{
this.DumpHostEntry(socket, message);
}
}
private void ProcessMessage(MalockSocket socket, MalockNnsMessage message, Stream stream)
{
switch (socket.LinkMode)
{
case MalockMessage.LINK_MODE_CLIENT:
this.ProcessClient(socket, message);
break;
case MalockMessage.LINK_MODE_SERVER:
this.ProcessServer(socket, message, stream);
break;
default:
socket.Abort();
break;
}
}
private void RegisterHostEntry(MalockSocket socket, int sequence, HostEntry entry)
{
MalockNnsMessage message = new MalockNnsMessage();
message.Sequence = sequence;
message.Command = MalockMessage.COMMON_COMMAND_ERROR;
if (entry != null)
{
lock (this.nnsTable.GetSynchronizationObject())
{
if (this.nnsTable.Register(socket.Identity, entry))
{
message.Command = MalockNnsMessage.SERVER_NDN_COMMAND_REGISTERHOSTENTRYINFO;
}
this.nnsTable.SetAvailable(socket.Identity, socket.Address, true);
}
}
MalockMessage.TrySendMessage(socket, message);
}
private void DumpHostEntry(MalockSocket socket, MalockNnsMessage message)
{
MalockNnsMessage msg = new MalockNnsMessage();
msg.Sequence = message.Sequence;
msg.Command = message.Command;
do
{
var hosts = this.nnsTable.GetAllHosts();
lock (this.nnsTable)
{
NnsTable.Host.SerializeAll(hosts, (count, stream) =>
{
using (MemoryStream ms = (MemoryStream)stream)
{
MalockMessage.TrySendMessage(socket, message, ms.GetBuffer(), 0, unchecked ((int)ms.Position));
}
});
}
} while (false);
}
private void ProcessAccept(object sender, MalockSocket e)
{
/*
*
*/
}
public static IPAddress QueryActiveIPAddress(int timeout = 300, string hostNameOrAddress = "www.baidu.com")
{
if (string.IsNullOrEmpty(hostNameOrAddress))
{
return(null);
}
using (AutoResetEvent events = new AutoResetEvent(false))
{
IPAddress address = null;
Stopwatch stopwatch = new Stopwatch();
bool istimedout = false;
try
{
Dns.BeginGetHostAddresses(hostNameOrAddress, (ar) =>
{
if (istimedout)
{
return;
}
try
{
IPAddress[] addresses = Dns.EndGetHostAddresses(ar);
if (addresses != null && addresses.Length > 0)
{
foreach (IPAddress i in addresses)
{
if (i.AddressFamily == AddressFamily.InterNetwork)
{
address = i;
break;
}
}
events.Set();
}
}
catch (Exception)
{
}
}, null);
}
catch (Exception)
{
return(null);
}
do
{
stopwatch.Start();
if (!events.WaitOne(timeout))
{
istimedout = true;
return(null);
}
else if (address == null)
{
return(null);
}
stopwatch.Stop();
} while (false);
timeout -= Convert.ToInt32(stopwatch.ElapsedMilliseconds);
if (timeout <= 0)
{
return(null);
}
using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
try
{
socket.NoDelay = true;
socket.BeginConnect(new IPEndPoint(address, 443), (ar) =>
{
if (istimedout)
{
return;
}
try
{
socket.EndConnect(ar);
EndPoint localEP = socket.LocalEndPoint;
if (localEP != null)
{
IPEndPoint ipep = (IPEndPoint)localEP;
address = ipep.Address;
events.Set();
}
}
catch (Exception)
{
address = null;
}
}, null);
}
catch (Exception)
{
return(null);
}
do
{
if (!events.WaitOne(timeout))
{
istimedout = true;
return(null);
}
} while (false);
MalockSocket.Close(socket);
}
return(address);
}
}
