protected virtual void OnReceived(object sender, MalockInnetSocketStream e)
{
MalockNodeMessage message = null;
using (Stream stream = e.Stream)
{
if (!MalockNodeMessage.TryDeserialize(e.Stream, out message))
{
this.Abort();
return;
}
if (message.Command == MalockNodeMessage.SERVER_COMMAND_SYN_LOADALLINFO)
{
this.LoadAllInfo(stream);
}
else if (message.Command == MalockNodeMessage.SERVER_COMMAND_SYN_ENTER)
{
this.Enter(message);
}
else if (message.Command == MalockNodeMessage.SERVER_COMMAND_SYN_EXIT)
{
this.Exit(message);
}
}
}
protected internal virtual bool TryGetAllInfo(int timeout, out IEnumerable <HandleInfo> infos, ref Exception exception)
{
IList <HandleInfo> out_infos = emptryhandleinfos;
Exception out_exception = null;
try
{
if (timeout <= 0 && timeout != -1)
{
out_exception = EventWaitHandle.NewTimeoutException();
return(false);
}
using (ManualResetEvent events = new ManualResetEvent(false))
{
bool success = false;
bool abort = false;
if (!MalockMessage.TryInvokeAsync(this, MalockNodeMessage.New(null, this.Identity,
MalockNodeMessage.CLIENT_COMMAND_GETALLINFO, timeout), timeout,
(errno, message, stream) =>
{
if (errno == MalockMessage.Mappable.ERROR_NOERROR)
{
if (message.Command == MalockNodeMessage.CLIENT_COMMAND_GETALLINFO)
{
out_infos = new List <HandleInfo>();
success = HandleInfo.Fill(out_infos, stream);
}
}
else if (errno == MalockMessage.Mappable.ERROR_ABORTED)
{
abort = true;
}
else if (errno == MalockMessage.Mappable.ERROR_TIMEOUT)
{
out_exception = EventWaitHandle.NewTimeoutException();
}
events.Set();
}, ref out_exception) || out_exception != null)
{
return(false);
}
events.WaitOne();
if (abort)
{
out_exception = EventWaitHandle.NewAbortedException();
return(false);
}
return(success);
}
}
finally
{
infos = out_infos;
exception = out_exception;
}
}
private void ProcessReceived(object sender, MalockSocketStream e)
{
MalockNodeMessage message = null;
using (Stream stream = e.Stream)
{
MalockNodeMessage.TryDeserialize(stream, out message);
}
if (message != null)
{
this.ProcessMessage(e.Socket, message);
}
}
protected internal virtual void GetAllInfoAsync(int timeout, Action <int, IEnumerable <HandleInfo> > state)
{
if (state == null)
{
throw new ArgumentNullException("callback");
}
if (timeout <= 0 && timeout != -1)
{
state(kERROR_TIMEOUT, emptryhandleinfos);
}
else
{
Exception exception = null;
if (!MalockMessage.TryInvokeAsync(this,
MalockNodeMessage.New(null, this.Identity, MalockNodeMessage.CLIENT_COMMAND_GETALLINFO, timeout), timeout,
(errno, message, stream) =>
{
if (errno == MalockMessage.Mappable.ERROR_NOERROR)
{
bool error = true;
if (message.Command == MalockNodeMessage.CLIENT_COMMAND_GETALLINFO)
{
IList <HandleInfo> results = new List <HandleInfo>();
if (HandleInfo.Fill(results, stream))
{
error = false;
state(kERROR_NOERROR, results);
}
}
if (error)
{
state(kERROR_ERRORNO, emptryhandleinfos);
}
}
else if (errno == MalockMessage.Mappable.ERROR_ABORTED)
{
state(kERROR_ABORTED, emptryhandleinfos);
}
else if (errno == MalockMessage.Mappable.ERROR_TIMEOUT)
{
state(kERROR_TIMEOUT, emptryhandleinfos);
}
}, ref exception))
{
state(kERROR_ABORTED, emptryhandleinfos);
}
}
}
private void ProcessMessage(MalockSocket socket, MalockNodeMessage message)
{
switch (socket.LinkMode)
{
case MalockMessage.LINK_MODE_CLIENT:
this.ProcessClient(socket, message);
break;
case MalockMessage.LINK_MODE_SERVER:
this.ProcessServer(socket, message);
break;
default:
socket.Abort();
break;
}
}
private void ProcessServer(MalockSocket socket, MalockNodeMessage message)
{
if (message.Command == MalockNodeMessage.SERVER_COMMAND_SYN_ENTER)
{
socket.UserToken = message;
MalockTable malock = this.malockEngine.GetTable();
malock.Enter(message.Key, message.Identity);
}
else if (message.Command == MalockNodeMessage.SERVER_COMMAND_SYN_EXIT)
{
MalockTable malock = this.malockEngine.GetTable();
malock.Exit(message.Key, message.Identity);
do
{
this.malockEngine.AckPipelineExit(new MalockTaskInfo()
{
Key = message.Key,
Identity = message.Identity,
});
} while (false);
}
else if (message.Command == MalockNodeMessage.SERVER_COMMAND_SYN_FREE)
{
string[] keys;
MalockTable malock = this.malockEngine.GetTable();
malock.Exit(message.Identity, out keys);
this.malockEngine.AckPipelineEnter(message.Identity, keys);
}
else if (message.Command == MalockNodeMessage.SERVER_COMMAND_SYN_LOADALLINFO)
{
this.malockEngine.GetAllInfo(new MalockTaskInfo()
{
Identity = socket.Identity,
Socket = socket,
Timeout = -1,
Type = MalockTaskType.kGetAllInfo
});
}
}
private void ProcessAborted(object sender, EventArgs e)
{
MalockSocket socket = (MalockSocket)sender;
if (socket.LinkMode == MalockMessage.LINK_MODE_CLIENT)
{
if (!string.IsNullOrEmpty(socket.Identity))
{
this.malockEngine.Abort(new MalockTaskInfo()
{
Type = MalockTaskType.kAbort,
Key = null,
Stopwatch = null,
Timeout = -1,
Sequence = MalockMessage.NewId(),
Socket = socket,
Identity = socket.Identity,
});
}
}
else if (socket.LinkMode == MalockMessage.LINK_MODE_SERVER)
{
MalockNodeMessage message = (MalockNodeMessage)socket.UserToken;
if (message != null)
{
string[] keys;
MalockTable malock = this.malockEngine.GetTable();
malock.Exit(message.Identity, out keys);
this.malockEngine.AckPipelineEnter(message.Identity, keys);
}
}
lock (socket)
{
socket.Aborted -= this.onAboredHandler;
socket.Connected -= this.onConnectedHandler;
socket.Received -= this.onReceivedHandler;
}
}
private MalockMessage NewMessage(string key, string identity, byte command, int sequence, int timeout)
{
return(MalockNodeMessage.New(key, identity, command, sequence, timeout));
}
protected MalockMessage NewMesssage(byte command, int timeout)
{
return(MalockNodeMessage.New(this.Key, this.GetIdentity(), command, timeout));
}
protected virtual void OnConnected(object sender, EventArgs e)
{
MalockMessage message = MalockNodeMessage.New(null, this.Identity, MalockNodeMessage.SERVER_COMMAND_SYN_LOADALLINFO, -1);
MalockMessage.TrySendMessage(this, message);
}
private void Enter(MalockNodeMessage message)
{
MalockTable malock = this.engine.GetTable();
malock.Enter(message.Key, message.Identity);
}
private void ProcessClient(MalockSocket socket, MalockNodeMessage message)
{
if (message.Command == MalockNodeMessage.CLIENT_COMMAND_LOCK_ENTER ||
message.Command == MalockNodeMessage.CLIENT_COMMAND_LOCK_EXIT ||
message.Command == MalockNodeMessage.CLIENT_COMMAND_GETALLINFO ||
message.Command == MalockNodeMessage.CLIENT_COMMAND_LOCK_ACKPIPELINEEXIT ||
message.Command == MalockNodeMessage.CLIENT_COMMAND_LOCK_ACKPIPELINEENTER)
{
MalockTaskInfo info = new MalockTaskInfo();
switch (message.Command)
{
case MalockNodeMessage.CLIENT_COMMAND_LOCK_ENTER:
info.Type = MalockTaskType.kEnter;
break;
case MalockNodeMessage.CLIENT_COMMAND_LOCK_EXIT:
info.Type = MalockTaskType.kExit;
break;
case MalockNodeMessage.CLIENT_COMMAND_GETALLINFO:
info.Type = MalockTaskType.kGetAllInfo;
break;
case MalockNodeMessage.CLIENT_COMMAND_LOCK_ACKPIPELINEEXIT:
info.Type = MalockTaskType.kAckPipelineExit;
break;
case MalockNodeMessage.CLIENT_COMMAND_LOCK_ACKPIPELINEENTER:
info.Type = MalockTaskType.kAckPipelineEnter;
break;
}
info.Sequence = message.Sequence;
info.Socket = socket;
info.Key = message.Key;
info.Identity = socket.Identity;
info.Timeout = message.Timeout;
do
{
Stopwatch sw = new Stopwatch();
info.Stopwatch = sw;
sw.Start();
} while (false);
if (message.Command == MalockNodeMessage.CLIENT_COMMAND_LOCK_EXIT)
{
this.malockEngine.Exit(info);
}
else if (message.Command == MalockNodeMessage.CLIENT_COMMAND_LOCK_ENTER)
{
if (this.malockEngine.Enter(info))
{
this.malockEngine.AckPipelineEnter(info);
}
else
{
this.malockEngine.GetPoll().Add(info);
}
}
else if (message.Command == MalockNodeMessage.CLIENT_COMMAND_LOCK_ACKPIPELINEEXIT)
{
this.malockEngine.AckPipelineExit(info); // anti-deadlock
}
else if (message.Command == MalockNodeMessage.CLIENT_COMMAND_LOCK_ACKPIPELINEENTER)
{
this.malockEngine.AckPipelineEnter(info);
}
else if (message.Command == MalockNodeMessage.CLIENT_COMMAND_GETALLINFO)
{
this.malockEngine.GetAllInfo(info);
}
}
}
