public async Task CanReceiveDataUsingTasksToHostedEchoServer()
{
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] input = Encoding.ASCII.GetBytes(request);
byte[] output = new byte[input.Length];
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
using (EchoServer server = new EchoServer(factory))
{
socket.Bind();
worker.Start();
server.Start();
await socket.Connect(server.Endpoint);
await socket.Send(input);
await socket.Receive(output);
Assert.That(input, Is.EqualTo(output));
}
}
}
public async Task CanHandleTerminatedStream()
{
IPAddress localhost = IPAddress.Loopback;
IPEndPoint endpoint = new IPEndPoint(localhost, 1234);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
using (TcpSocket server = factory.Tcp())
using (TcpSocket socket = factory.Tcp())
{
socket.Bind();
worker.Start();
server.Bind(endpoint.Port);
server.Listen(1);
Task <TcpSocketAccept> acceptable = server.Accept();
await socket.Connect(endpoint);
TcpSocketAccept accepted = await acceptable;
accepted.Connection.Dispose();
byte[] buffer = new byte[10];
TcpSocketSend sent = await socket.Send(buffer);
Assert.That(sent.Status, Is.EqualTo(SocketStatus.OK));
}
}
}
public void CanConnectUsingCallbackToExampleSite()
{
TimeSpan timeout = TimeSpan.FromSeconds(2);
ManualResetEvent check = new ManualResetEvent(false);
IPAddress[] addresses = Dns.GetHostAddresses("www.example.com");
IPEndPoint endpoint = new IPEndPoint(addresses[0], 80);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
worker.Start();
TcpSocketConnectCallback onConnected = result =>
{
check.Set();
};
socket.Connect(endpoint, onConnected);
bool completed = check.WaitOne(timeout);
Assert.That(completed, Is.True);
}
}
public void CanStart()
{
using (CompletionThread worker = new CompletionThread())
{
worker.Start();
}
}
public void CanWriteData()
{
byte[] buffer = new byte[20];
ManualResetEvent completed = new ManualResetEvent(false);
using (CompletionThread worker = new CompletionThread())
{
string path = Path.Combine(sandbox.Directory, "abc.txt");
FileFactory factory = new FileFactory(worker);
worker.Start();
using (File file = factory.OpenOrCreate(path))
{
file.Write(0, buffer, data =>
{
completed.Set();
});
}
using (FileStream stream = System.IO.File.OpenRead(path))
{
stream.Read(new byte[10], 0, 10);
}
}
Assert.That(completed.WaitOne(TimeSpan.FromSeconds(5)), Is.True);
}
public void CanReadDataAtTheEndOfFile()
{
byte[] buffer = new byte[20];
ManualResetEvent completed = new ManualResetEvent(false);
using (CompletionThread worker = new CompletionThread())
{
string path = Path.Combine(sandbox.Directory, "abc.txt");
FileFactory factory = new FileFactory(worker);
using (FileStream stream = System.IO.File.Create(path))
{
stream.Write(new byte[10], 0, 10);
stream.Flush(true);
worker.Start();
}
using (File file = factory.OpenOrCreate(path))
{
file.Read(10, buffer, data =>
{
Assert.That(data.Count, Is.EqualTo(0));
completed.Set();
});
Assert.That(completed.WaitOne(TimeSpan.FromSeconds(5)), Is.True);
}
}
}
public void Start(TrackerGetHooks hooks)
{
lock (this)
{
if (pipeline == null)
{
pipeline = new LeakPipeline();
pipeline.Start();
}
if (worker == null)
{
worker = new CompletionThread();
worker.Start();
}
if (service == null)
{
service =
new TrackerGetBuilder()
.WithPipeline(pipeline)
.WithWorker(worker)
.Build(hooks);
service.Start();
}
}
}
public async Task CanObtainAcceptedRemoteEndpointUsingTasks()
{
using (CompletionThread worker = new CompletionThread())
{
IPEndPoint endpoint;
SocketFactory factory = new SocketFactory(worker);
using (TcpSocket server = factory.Tcp())
using (TcpSocket client = factory.Tcp())
{
worker.Start();
client.Bind();
server.Bind(IPAddress.Loopback);
server.Listen(1);
endpoint = server.Info().Endpoint;
Task <TcpSocketAccept> accepting = server.Accept();
await client.Connect(endpoint);
TcpSocketAccept accepted = await accepting;
IPEndPoint remote = accepted.GetRemote();
Assert.That(remote.Address, Is.EqualTo(endpoint.Address));
Assert.That(remote.Port, Is.Not.EqualTo(endpoint.Port));
Assert.That(remote.Port, Is.Not.Zero);
}
}
}
public void CanSendDataUsingCallbackToExampleSite()
{
TimeSpan timeout = TimeSpan.FromSeconds(2);
ManualResetEvent check = new ManualResetEvent(false);
IPAddress[] addresses = Dns.GetHostAddresses("www.example.com");
IPEndPoint endpoint = new IPEndPoint(addresses[0], 80);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
worker.Start();
TcpSocketSendCallback onSent = result =>
{
check.Set();
};
TcpSocketConnectCallback onConnected = result =>
{
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] data = Encoding.ASCII.GetBytes(request);
socket.Send(data, onSent);
};
socket.Connect(endpoint, onConnected);
bool completed = check.WaitOne(timeout);
Assert.That(completed, Is.True);
}
}
public MetashareFixture()
{
pipeline = new PipelineSimulator();
completion = new CompletionThread();
completion.Start();
files = new FileFactory(completion);
}
public RepositoryFixture()
{
pipeline = new LeakPipeline();
pipeline.Start();
completion = new CompletionThread();
completion.Start();
files = new FileFactory(completion);
}
public ConnectorFixture()
{
pipeline = new LeakPipeline();
pipeline.Start();
worker = new CompletionThread();
worker.Start();
pool =
new NetworkPoolBuilder()
.WithPipeline(pipeline)
.WithWorker(worker)
.WithMemory(new ConnectorMemory())
.Build();
pool.Start();
hooks = new PeerConnectorHooks();
}
public async Task CanHandleRequest()
{
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
EchoClient client = new EchoClient(factory);
using (EchoServer server = new EchoServer(factory))
{
worker.Start();
server.Start();
string payload = "abc";
string response = await client.Send(server.Endpoint, payload);
Assert.That(response, Is.EqualTo(payload));
}
}
}
public LoopFixture()
{
pipeline = new LeakPipeline();
pipeline.Start();
worker = new CompletionThread();
worker.Start();
pool =
new NetworkPoolBuilder()
.WithPipeline(pipeline)
.WithWorker(worker)
.WithMemory(new LoopMemory())
.Build();
pool.Start();
hooks = new ReceiverHooks();
samples = new LoopSamples();
}
public async Task CanConnectUsingTasksToNotAvailableSite()
{
IPAddress[] addresses = Dns.GetHostAddresses("www.example.com");
IPEndPoint endpoint = new IPEndPoint(addresses[0], 8123);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
worker.Start();
TcpSocketConnect connect = await socket.Connect(endpoint);
SocketStatus expected = SocketStatus.TimedOut;
Assert.That(connect.Status, Is.EqualTo(expected));
}
}
public static void Main(string[] args)
{
using (CompletionThread worker = new CompletionThread())
{
EchoOptions options = Argument.Parse <EchoOptions>(args);
SocketFactory factory = new SocketFactory(worker);
worker.Start();
if (options.Server != null)
{
EchoServerStarter.Start(options.Server, factory);
}
if (options.Benchmark != null)
{
EchoBenchmarkStarter.Start(options.Benchmark, factory);
}
}
}
public void CanTransferDataUsingUdpSockets()
{
using (CompletionThread worker = new CompletionThread())
{
worker.Start();
using (ManualResetEvent sync = new ManualResetEvent(false))
{
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, 44556);
byte[] data = Encoding.ASCII.GetBytes("abc");
SocketBuffer buffer = new SocketBuffer(data);
SocketFactory factory = new SocketFactory(worker);
using (UdpSocket sender = factory.Udp())
using (UdpSocket receiver = factory.Udp())
{
sender.Bind();
receiver.Bind(endpoint.Port);
receiver.Receive(new SocketBuffer(10), received =>
{
Assert.That(received.Status, Is.EqualTo(SocketStatus.OK));
Assert.That(received.Count, Is.EqualTo(3));
Assert.That(received.Buffer.Data.Take(3), Is.EqualTo(data));
sync.Set();
});
sender.Send(endpoint, buffer, sent =>
{
Assert.That(sent.Status, Is.EqualTo(SocketStatus.OK));
Assert.That(sent.Count, Is.EqualTo(3));
});
}
Assert.That(sync.WaitOne(200), Is.True);
}
}
}
public void Start()
{
lock (this)
{
if (pipeline == null)
{
pipeline = new LeakPipeline();
pipeline.Start();
}
if (worker == null)
{
worker = new CompletionThread();
worker.Start();
}
if (files == null)
{
files = new FileFactory(worker);
}
}
}
public async Task CanSendDataUsingAsyncToExampleSite()
{
IPAddress[] addresses = Dns.GetHostAddresses("www.example.com");
IPEndPoint endpoint = new IPEndPoint(addresses[0], 80);
string request = "GET /index.html HTTP/1.1\r\nHost: www.example.com\r\n\r\n";
byte[] data = Encoding.ASCII.GetBytes(request);
using (CompletionThread worker = new CompletionThread())
{
SocketFactory factory = new SocketFactory(worker);
TcpSocket socket = factory.Tcp();
socket.Bind();
worker.Start();
await socket.Connect(endpoint);
await socket.Send(data);
}
}
public NegotiatorFixture()
{
pipeline = new LeakPipeline();
pipeline.Start();
worker = new CompletionThread();
worker.Start();
pool =
new NetworkPoolBuilder()
.WithPipeline(pipeline)
.WithWorker(worker)
.WithMemory(new NegotiatorMemory())
.Build();
pool.Start();
hooks = new HandshakeNegotiatorHooks();
negotiator =
new HandshakeNegotiatorBuilder()
.WithNetwork(pool)
.Build(hooks);
}