public void Send(Command command)
{
bool ok;
lock (m_sync)
{
m_commandPipe.Write(ref command, false);
ok = m_commandPipe.Flush();
}
if (!ok)
{
m_proactor.SignalMailbox(this);
}
}
/// <summary>
/// Send a command to the given destination thread.
/// </summary>
public void SendCommand(int threadId, Command command)
{
m_slots[threadId].Send(command);
}
public bool TryReceive(TimeSpan timeout, out Command command)
{
return m_queue.TryTake(out command, timeout);
}
public void Send(Command command)
{
m_queue.Add(command);
}
internal static void SendCommand(int slotId, Command command)
{
s_slots[slotId].Send(command);
}
public void ProcessCommand( Command cmd)
{
switch (cmd.CommandType)
{
case CommandType.ActivateRead:
ProcessActivateRead();
break;
case CommandType.ActivateWrite:
ProcessActivateWrite((long)cmd.Arg);
break;
case CommandType.Stop:
ProcessStop();
break;
case CommandType.Plug:
ProcessPlug();
ProcessSeqnum();
break;
case CommandType.Own:
ProcessOwn((Own)cmd.Arg);
ProcessSeqnum();
break;
case CommandType.Attach:
ProcessAttach((IEngine)cmd.Arg);
ProcessSeqnum();
break;
case CommandType.Bind:
ProcessBind((Pipe)cmd.Arg);
ProcessSeqnum();
break;
case CommandType.Hiccup:
ProcessHiccup(cmd.Arg);
break;
case CommandType.PipeTerm:
ProcessPipeTerm();
break;
case CommandType.PipeTermAck:
ProcessPipeTermAck();
break;
case CommandType.TermReq:
ProcessTermReq((Own)cmd.Arg);
break;
case CommandType.Term:
ProcessTerm((int)cmd.Arg);
break;
case CommandType.TermAck:
ProcessTermAck();
break;
case CommandType.Reap:
ProcessReap((SocketBase)cmd.Arg);
break;
case CommandType.Reaped:
ProcessReaped();
break;
default:
throw new ArgumentException();
}
}
/// <summary>
/// Send the given Command, on that commands Destination thread.
/// </summary>
/// <param name="cmd">the Command to send</param>
private void SendCommand( Command cmd)
{
m_ctx.SendCommand(cmd.Destination.ThreadId, cmd);
}
public bool TryRecv(out Command command)
{
return m_commandPipe.TryRead(out command);
}
/// <summary>
/// Receive and return a Command from the command-pipe.
/// </summary>
/// <param name="timeout">how long to wait for a command (in milliseconds) before returning</param>
/// <param name="command"></param>
public bool TryRecv(int timeout, out Command command)
{
// Try to get the command straight away.
if (m_active)
{
if (m_commandPipe.TryRead(out command))
return true;
// If there are no more commands available, switch into passive state.
m_active = false;
m_signaler.Recv();
}
// Wait for signal from the command sender.
if (!m_signaler.WaitEvent(timeout))
{
command = default(Command);
return false;
}
// We've got the signal. Now we can switch into active state.
m_active = true;
// Get a command.
var ok = m_commandPipe.TryRead(out command);
Debug.Assert(ok);
return ok;
}
/// <summary>
/// Send the given Command out accross the command-pipe.
/// </summary>
/// <param name="cmd">the Command to send</param>
public void Send(Command cmd)
{
bool ok;
lock (m_sync)
{
m_commandPipe.Write(ref cmd, false);
ok = m_commandPipe.Flush();
}
//if (LOG.isDebugEnabled())
// LOG.debug( "{} -> {} / {} {}", new Object[] { Thread.currentThread().getName(), cmd_, cmd_.arg , !ok});
if (!ok)
{
m_signaler.Send();
}
}
private static void SendCommand(Command command)
{
SocketManager.SendCommand(command.Destination.SlotId, command);
}
public void Send(Command command)
{
// using the completion port as a queue, might not yield good performance
m_completionPort.Signal(command);
}