public Proactor([NotNull] string name)
{
m_name = name;
m_stopping = false;
m_stopped = false;
m_completionPort = CompletionPort.Create();
m_sockets = new Dictionary <AsyncSocket, Item>();
}
public void RemoteEndPoint()
{
CompletionPort completionPort = CompletionPort.Create();
var listenSocket = AsyncSocket.CreateIPv4Tcp();
completionPort.AssociateSocket(listenSocket, null);
listenSocket.Bind(IPAddress.Any, 0);
int port = listenSocket.LocalEndPoint.Port;
listenSocket.Listen(1);
listenSocket.Accept();
var clientSocket = AsyncSocket.CreateIPv4Tcp();
completionPort.AssociateSocket(clientSocket, null);
clientSocket.Bind(IPAddress.Any, 0);
clientSocket.Connect("localhost", port);
CompletionStatus completionStatus;
bool accepted = false;
bool connected = false;
while (!accepted || !connected)
{
completionPort.GetQueuedCompletionStatus(-1, out completionStatus);
if (completionStatus.AsyncSocket == clientSocket && !connected)
{
Assert.AreEqual(OperationType.Connect, completionStatus.OperationType);
Assert.AreEqual(SocketError.Success, completionStatus.SocketError);
connected = true;
}
else if (completionStatus.AsyncSocket == listenSocket && !accepted)
{
Assert.AreEqual(OperationType.Accept, completionStatus.OperationType);
Assert.AreEqual(SocketError.Success, completionStatus.SocketError);
accepted = true;
}
else
{
Assert.Fail();
}
}
var server = listenSocket.GetAcceptedSocket();
Assert.AreEqual(clientSocket.LocalEndPoint, server.RemoteEndPoint);
Assert.AreEqual(clientSocket.RemoteEndPoint, server.LocalEndPoint);
completionPort.Dispose();
listenSocket.Dispose();
server.Dispose();
clientSocket.Dispose();
}
IEnumerator <ITask> UpdateSensorData(DateTime dateTime)
{
var resultPort = new CompletionPort();
PostOnTaskCompletion(resultPort, UpdateColorSensor);
PostOnTaskCompletion(resultPort, UpdateBrightnessSensor);
PostOnTaskCompletion(resultPort, UpdateCompass);
PostOnTaskCompletion(resultPort, UpdateLRF);
PostOnTaskCompletion(resultPort, UpdateSonar);
PostOnTaskCompletion(resultPort, UpdateInfrared);
PostOnTaskCompletion(resultPort, UpdateWebCamImage);
Activate(Arbiter.MultipleItemReceive(false, resultPort, 7, allComplete =>
{
Activate(Arbiter.ReceiveWithIterator(false, _dateTimePort, UpdateSensorData));
TaskQueue.EnqueueTimer(TimeSpan.FromMilliseconds(60), _dateTimePort);
}));
yield break;
}
static void Main(string[] args)
{
ForceDotNet.Force();
CompletionPort completionPort = CompletionPort.Create();
AutoResetEvent listenerEvent = new AutoResetEvent(false);
AutoResetEvent clientEvent = new AutoResetEvent(false);
AutoResetEvent serverEvent = new AutoResetEvent(false);
AsyncSocket listener = AsyncSocket.Create(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
completionPort.AssociateSocket(listener, listenerEvent);
AsyncSocket server = AsyncSocket.Create(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
completionPort.AssociateSocket(server, serverEvent);
AsyncSocket client = AsyncSocket.Create(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
completionPort.AssociateSocket(client, clientEvent);
Task.Factory.StartNew(() =>
{
CompletionStatus [] completionStatuses = new CompletionStatus[10];
int removed;
while (true)
{
var result = completionPort.GetMultipleQueuedCompletionStatus(-1, completionStatuses, out removed);
for (int i = 0; i < removed; i++)
{
var completionStatus = completionStatuses[i];
Console.WriteLine("{0} {1} {2}", completionStatus.SocketError, completionStatus.OperationType,
completionStatus.BytesTransferred);
if (completionStatus.State != null)
{
AutoResetEvent resetEvent = (AutoResetEvent)completionStatus.State;
resetEvent.Set();
}
}
Console.WriteLine("Handled {0} statuses", removed);
Thread.Sleep(100);
}
});
listener.Bind(IPAddress.Any, 5555);
listener.Listen(1);
//Console.WriteLine(listener.LocalEndPoint);
client.Bind(IPAddress.Any, 0);
client.Connect("localhost", 5555);
////Thread.Sleep(100);
listener.Accept(server);
listenerEvent.WaitOne();
clientEvent.WaitOne();
byte[] sendBuffer = new byte[1] {
2
};
byte[] recvBuffer = new byte[1];
server.Receive(recvBuffer);
client.Send(sendBuffer);
clientEvent.WaitOne();
serverEvent.WaitOne();
////Console.WriteLine("server received");
Console.ReadLine();
}
void PostOnTaskCompletion(CompletionPort completionPort, IteratorHandler handler)
{
SpawnIterator <CompletionPort, IteratorHandler>(completionPort, handler, PostOnTaskCompletionHelper);
}
IEnumerator <ITask> PostOnTaskCompletionHelper(CompletionPort completionPort, IteratorHandler handler)
{
yield return(new IterativeTask(handler));
completionPort.Post(true);
}
internal void SetCompletionPort(CompletionPort completionPort, object state)
{
m_completionPort = completionPort;
m_state = state;
}
public static void Main(string[] args)
{
CompletionPort completionPort = CompletionPort.Create();
AutoResetEvent listenerEvent = new AutoResetEvent(false);
AutoResetEvent clientEvent = new AutoResetEvent(false);
AutoResetEvent serverEvent = new AutoResetEvent(false);
AsyncSocket listener = AsyncSocket.Create(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
completionPort.AssociateSocket(listener, listenerEvent);
AsyncSocket server = AsyncSocket.Create(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
completionPort.AssociateSocket(server, serverEvent);
AsyncSocket client = AsyncSocket.Create(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
completionPort.AssociateSocket(client, clientEvent);
Task.Factory.StartNew(() =>
{
CompletionStatus completionStatus;
while (true)
{
var result = completionPort.GetQueuedCompletionStatus(-1, out completionStatus);
if (result)
{
Console.WriteLine("{0} {1} {2}", completionStatus.SocketError,
completionStatus.OperationType, completionStatus.BytesTransferred);
if (completionStatus.State != null)
{
AutoResetEvent resetEvent = (AutoResetEvent)completionStatus.State;
resetEvent.Set();
}
}
}
});
listener.Bind(IPAddress.Any, 5555);
listener.Listen(1);
client.Connect("localhost", 5555);
listener.Accept(server);
listenerEvent.WaitOne();
clientEvent.WaitOne();
byte[] sendBuffer = new byte[1] {
2
};
byte[] recvBuffer = new byte[1];
client.Send(sendBuffer);
server.Receive(recvBuffer);
clientEvent.WaitOne();
serverEvent.WaitOne();
server.Dispose();
client.Dispose();
Console.ReadLine();
}
public void SendReceive()
{
CompletionPort completionPort = CompletionPort.Create();
bool exception = false;
var task = Task.Factory.StartNew(() =>
{
bool cancel = false;
while (!cancel)
{
CompletionStatus [] completionStatuses = new CompletionStatus[10];
int removed;
completionPort.GetMultipleQueuedCompletionStatus(-1, completionStatuses, out removed);
for (int i = 0; i < removed; i++)
{
if (completionStatuses[i].OperationType == OperationType.Signal)
{
cancel = true;
}
else if (completionStatuses[i].SocketError == SocketError.Success)
{
EventWaitHandle manualResetEvent = (EventWaitHandle)completionStatuses[i].State;
manualResetEvent.Set();
}
else
{
exception = true;
}
}
}
});
AutoResetEvent clientEvent = new AutoResetEvent(false);
AutoResetEvent acceptedEvent = new AutoResetEvent(false);
AsyncSocket listener = AsyncSocket.CreateIPv4Tcp();
completionPort.AssociateSocket(listener, acceptedEvent);
listener.Bind(IPAddress.Any, 0);
int port = listener.LocalEndPoint.Port;
listener.Listen(1);
listener.Accept();
AsyncSocket clientSocket = AsyncSocket.CreateIPv4Tcp();
completionPort.AssociateSocket(clientSocket, clientEvent);
clientSocket.Bind(IPAddress.Any, 0);
clientSocket.Connect("localhost", port);
clientEvent.WaitOne();
acceptedEvent.WaitOne();
var serverSocket = listener.GetAcceptedSocket();
AutoResetEvent serverEvent = new AutoResetEvent(false);
completionPort.AssociateSocket(serverSocket, serverEvent);
byte[] recv = new byte[1];
serverSocket.Receive(recv);
byte[] data = new[] { (byte)1 };
clientSocket.Send(data);
clientEvent.WaitOne(); // wait for data to be send
serverEvent.WaitOne(); // wait for data to be received
Assert.AreEqual(1, recv[0]);
completionPort.Signal(null);
task.Wait();
Assert.IsFalse(exception);
completionPort.Dispose();
listener.Dispose();
serverSocket.Dispose();
clientSocket.Dispose();
}
