public Server()
{
_server = ServerBuilder.CreateAsync(new IPEndPoint(IPAddress.Parse("11.11.11.10"), 12345))
.WithCommand("ECHO")
.ExpectsNoData()
.HandledBy(r => Response.Create("OK").WithArguments(r.Arguments))
.Register()
.WithCommand("REPEAT")
.ExpectsNoData()
.HandledBy(r => {
var n = int.Parse(r.Arguments[0]);
var wat = r.Arguments[1];
var enumerable = Enumerable.Repeat(wat, n)
.Select((x, i) => Response.Create("OK").WithArgument(i).WithArgument(x))
.Concat(new[] { Response.Create("DONE") });
return(enumerable);
})
.Register()
// Async Handler version of ECHO
.WithCommand("ECHO2")
.HandledBy((r, c) => {
Console.WriteLine("got ECHO");
c(Response.Create("ECHO").WithArguments(r.Arguments));
})
.Register()
// Async Handler version of ECHO
.WithCommand("REPEAT2")
.ExpectsData()
.HandledBy((r, c) => {
var n = int.Parse(r.Arguments[0]);
var wat = r.Arguments[1];
var enumerator = Enumerable.Repeat(wat, n).Select((X, I) => new { X, I }).GetEnumerator();
Action f = null;
f = () => {
if (!enumerator.MoveNext())
{
c(Response.Create("DONE"), null);
return;
}
var v = enumerator.Current;
c(Response.Create("OK").WithArgument(v.I).WithArgument(v.X), f);
};
f();
})
.Register()
.WithDefaultHandler(r => {
Console.WriteLine("Got '{0}'", r.Command);
return(Response.Create("WAT"));
})
.Build();
}
public DungeonServer(IPEndPoint endpoint, ILog log)
{
_log = log;
_house = new TheHouse();
_server = ServerBuilder.CreateAsync(endpoint)
.WithCommand("JOIN").ExpectsData().HandledBy(r => {
var name = Encoding.ASCII.GetString(r.Data);
var player = _house.Join(name);
_playerConnectionLookup[r.Client] = player;
_log.Debug("server: '{0}' joined as '{1}'", name, player.Name);
return(Response.Create("OK").WithData(Encode(name)));
}).Register()
.WithCommand("LEAVE").ExpectsNoData().HandledBy(r => {
var player = _playerConnectionLookup[r.Client];
_house.Leave(player);
_log.Debug("server: '{0}' left", player.Name);
return(Response.Create("OK"));
}).Register()
.WithCommand("LISTEN").ExpectsNoData().HandledBy(r => {
var player = _playerConnectionLookup[r.Client];
return(Response.Create("OK").WithData(Encode(string.Join("\r\n", player.Listen()))));
}).Register()
.WithCommand("LOOK").ExpectsNoData().HandledBy(r => {
var player = _playerConnectionLookup[r.Client];
return(Response.Create("OK").WithData(Encode(player.Look())));
}).Register()
.WithCommand("LOCATION").ExpectsNoData().HandledBy(r => {
var player = _playerConnectionLookup[r.Client];
return(Response.Create("OK").WithData(Encode(player.Location.Name)));
}).Register()
.WithCommand("GO").ExpectsNoData().HandledBy(r => {
var player = _playerConnectionLookup[r.Client];
var direction = (Direction)Enum.Parse(typeof(Direction), r.Arguments[0], true);
return(Response.Create("OK").WithData(Encode(player.Go(direction))));
}).Register()
.WithCommand("SAY").ExpectsData().HandledBy(r => {
var player = _playerConnectionLookup[r.Client];
player.Say(Encoding.ASCII.GetString(r.Data));
return(Response.Create("OK"));
}).Register()
.OnClientDisconnected((id, ip) => {
var player = _playerConnectionLookup[ip];
player.Dispose();
_playerConnectionLookup.Remove(ip);
})
.Build();
log.Debug("started server on {0}", endpoint);
}
private void DisconnectTest(ClacksServer server) {
_log.Debug("creating server");
using(server) {
_log.Debug("created server");
using(var client = new ClacksClient("127.0.0.1", _port)) {
Assert.IsFalse(client.Disposed);
Console.WriteLine("created client");
var response = client.Exec(new Client.Request("BYE"));
_log.Debug("got response");
Assert.AreEqual("BYE", response.Status);
_log.Debug("checking disposed");
var c = 0;
while(!client.Disposed) {
c++;
if(c > 100) {
Assert.Fail("client was not disposed");
}
Thread.Sleep(100);
}
}
}
}
private void Receive_large_binary_payload(ClacksServer server) {
using(server) {
Console.WriteLine("created server");
using(var client = new ClacksClient("127.0.0.1", _port)) {
Console.WriteLine("created client");
var response = client.Exec(new Client.Request("BIN").ExpectData("OK"));
Console.WriteLine("got response");
Assert.AreEqual("OK", response.Status);
Assert.AreEqual(LargeBin.Length, response.Data.Length);
Assert.AreEqual(LargeBin, response.Data);
}
}
}
private void Send_large_binary_payload(ClacksServer server) {
using(server) {
Console.WriteLine("created server");
using(var client = new ClacksClient("127.0.0.1", _port)) {
Console.WriteLine("created client");
var response = client.Exec(new Client.Request("BIN").WithData(LargeBin));
Console.WriteLine("got response");
Assert.AreEqual("OK", response.Status);
}
}
}
private void Expect_error_handler(ClacksServer server) {
using(server) {
Console.WriteLine("created server");
using(var client = new ClacksClient("127.0.0.1", _port)) {
Console.WriteLine("created client");
var response = client.Exec(new Client.Request("FAIL"));
Console.WriteLine("got response");
Assert.AreEqual("ERROR", response.Status);
}
}
}
private void Receive_multi_response(ClacksServer server) {
using(server) {
Console.WriteLine("created server");
using(var client = new ClacksClient("127.0.0.1", _port)) {
Console.WriteLine("created client");
var responses = client.Exec(new MultiRequest("MULTI")
.WithArgument("foo")
.WithArgument("bar")
.ExpectMultiple("VALUE", false)
.TerminatedBy("END")
);
Console.WriteLine("got responses");
Assert.AreEqual(3, responses.Count());
var r = responses.ToArray();
Assert.AreEqual("VALUE", r[0].Status);
Assert.AreEqual(1, r[0].Arguments.Length);
Assert.AreEqual("foo", r[0].Arguments[0]);
Assert.AreEqual("VALUE", r[1].Status);
Assert.AreEqual(1, r[1].Arguments.Length, string.Join(",", r[1].Arguments));
Assert.AreEqual("bar", r[1].Arguments[0]);
Assert.AreEqual("END", r[2].Status);
Assert.AreEqual(0, r[2].Arguments.Length, string.Join(",", r[2].Arguments));
}
}
}
private void Receive_multi_binary_payload(ClacksServer server) {
using(server) {
Console.WriteLine("created server");
using(var client = new ClacksClient("127.0.0.1", _port)) {
Console.WriteLine("created client");
var responses = client.Exec(new MultiRequest("MULTI")
.WithArgument("foo")
.WithArgument("bar")
.ExpectMultiple("VALUE", true)
.TerminatedBy("END")
);
Console.WriteLine("got responses");
Assert.AreEqual(3, responses.Count());
Assert.AreEqual("VALUE", responses.ElementAt(0).Status);
Assert.AreEqual("foo", Encoding.ASCII.GetString(responses.ElementAt(0).Data));
Assert.AreEqual("VALUE", responses.ElementAt(1).Status);
Assert.AreEqual("bar", Encoding.ASCII.GetString(responses.ElementAt(1).Data));
Assert.AreEqual("END", responses.ElementAt(2).Status);
}
}
}
private void Receive_binary_payload(ClacksServer server, string payloadstring, byte[] payload) {
using(server) {
Console.WriteLine("created server");
using(var client = new ClacksClient("127.0.0.1", _port)) {
Console.WriteLine("created client");
var response = client.Exec(new Client.Request("foo").ExpectData("OK"));
Console.WriteLine("got response");
Assert.AreEqual("OK", response.Status);
Assert.AreEqual(1, response.Arguments.Length);
Assert.AreEqual(payload.Length, response.Data.Length);
Assert.AreEqual(payload, response.Data);
}
}
}
private void Can_send_binary_payload_with_auto_data_detection(ClacksServer server) {
var payloadString = "blahblahblah";
var payload = Encoding.ASCII.GetBytes(payloadString);
using(server) {
Console.WriteLine("created server");
using(var client = new ClacksClient("127.0.0.1", _port)) {
Console.WriteLine("created client");
var response = client.Exec(new Client.Request("foo").WithData(payload));
Console.WriteLine("got response");
Assert.AreEqual("OK", response.Status);
Assert.AreEqual(2, response.Arguments.Length);
Assert.AreEqual(payload.Length.ToString(), response.Arguments[0]);
Assert.AreEqual(payloadString, response.Arguments[1]);
}
}
}
private void EchoData(ClacksServer server) {
using(server) {
Console.WriteLine("created server");
using(var client = new ClacksClient("127.0.0.1", _port)) {
Console.WriteLine("created client");
var response = client.Exec(new Client.Request("ECHO").WithArgument("foo").WithArgument("bar"));
Console.WriteLine("got response");
Assert.AreEqual("ECHO", response.Status);
Assert.AreEqual(new[] { "foo", "bar" }, response.Arguments);
}
}
}
private void Expect_error_handler(string errorStatus, ClacksServer server) {
using(server) {
Console.WriteLine("created server");
using(var client = new ClacksClient(_endpoint)) {
Console.WriteLine("created client");
var response = client.Exec(new Client.Request("FAIL"));
Console.WriteLine("got response");
Assert.AreEqual(errorStatus, response.Status);
}
}
}