internal HttpSession(LibNetworkConfig config, ITcpSession session, CancellationToken token)
{
_config = config;
_session = session;
_canceller = new CancellationTokenSource();
_token = token;
_closed = false;
last_response_time = new TimeSpan(DateTime.UtcNow.Ticks);
last_pulse_time = last_response_time;
Name = nameof(HttpSession);
Id = Guid.NewGuid();
Timeout = config.Http.SessionTimeout;
OnGET = delegate { return(Task.CompletedTask); };
OnDELETE = delegate { return(Task.CompletedTask); };
OnPUT = delegate { return(Task.CompletedTask); };
OnPOST = delegate { return(Task.CompletedTask); };
OnHEAD = delegate { return(Task.CompletedTask); };
OnPATCH = delegate { return(Task.CompletedTask); };
OnTRACE = delegate { return(Task.CompletedTask); };
OnOPTIONS = delegate { return(Task.CompletedTask); };
OnCONNECT = delegate { return(Task.CompletedTask); };
OnAnyValidRequest = delegate { return(Task.CompletedTask); };
OnInvalidRequest = delegate { return(Task.CompletedTask); };
OnTimeoutDisconnect = delegate { return(Task.CompletedTask); };
OnUnhandledException = delegate { return(Task.CompletedTask); };
}
public HttpServer(LibNetworkConfig config)
{
Config = config;
SessionFactory = config.Factories.TcpSessionFactoryFactory(config);
Sessions = new ConcurrentDictionary <Guid, IHttpSession>();
SessionTasks = new ConcurrentDictionary <Guid, Task>();
OnNewConnection = delegate { return(Task.CompletedTask); };
OnUnhandledException = delegate { return(Task.CompletedTask); };
OnSessionException = delegate { return(Task.CompletedTask); };
OnSocketException = delegate { return(Task.CompletedTask); };
}
public async Task basic_test_1()
{
var got_request = false;
var got_response = false;
var server1_err_spot = 0;
var server2_err_spot = 0;
Exception?server1_exception = null;
Exception?server2_exception = null;
const bool thread_per_connection = true;
const int interval = 15;
var config1 = new LibNetworkConfig()
{
Port = 1,
Http = new HttpConfig()
{
ThreadPerConnection = thread_per_connection,
ConnectionLoopMillisecondDelayInterval = interval,
}
};
var mock_session_factory1 = new MockTcpSessionFactory(config1);
config1.Factories.TcpSessionFactoryFactory = _ => mock_session_factory1;
var config2 = new LibNetworkConfig()
{
Port = 2,
Http = new HttpConfig()
{
ThreadPerConnection = thread_per_connection,
ConnectionLoopMillisecondDelayInterval = interval,
}
};
var mock_session_factory2 = new MockTcpSessionFactory(config2);
config2.Factories.TcpSessionFactoryFactory = _ => mock_session_factory2;
var server1 = new HttpServer(config1);
var server2 = new HttpServer(config2);
server1.OnUnhandledException += e => { server1_exception = e; server1_err_spot = 1; return(Task.CompletedTask); };
server2.OnUnhandledException += e => { server2_exception = e; server2_err_spot = 1; return(Task.CompletedTask); };
server1.OnSessionException += e => { server1_exception = e; server1_err_spot = 2; return(Task.CompletedTask); };
server2.OnSessionException += e => { server2_exception = e; server2_err_spot = 2; return(Task.CompletedTask); };
server2.OnNewConnection += session =>
{
session.OnUnhandledException += e => { server2_exception = e; server2_err_spot = 3; return(Task.CompletedTask); };
session.OnGET += async(req, session) =>
{
got_request = true;
var response = new HttpResponse(
HttpVersion.HTTP1_1,
HttpStatusCode.OK,
new HttpMessage(
new HttpHeaders()
{
new HttpHeader("Accept-Language", "en-US"),
new HttpHeader("Host", "localhost:2"),
},
new HttpBody(
"{\r\n \"message\": \"hello back to you!\"\r\n}"
)
)
);
await Task.Delay(1_000);
await session.Respond(response);
};
return(Task.CompletedTask);
};
var server1_task = server1.StartAsync();
var server2_task = server2.StartAsync();
_ = server1_task.ContinueWith(t => { if (t.IsFaulted)
{
server1_exception = t.Exception; server1_err_spot = 4;
}
});
_ = server2_task.ContinueWith(t => { if (t.IsFaulted)
{
server2_exception = t.Exception; server2_err_spot = 4;
}
});
// FIXME: server needs time to boot up
await Task.Delay(1_000);
var request1 = new HttpRequest(
HttpRequestKind.GET,
"/some/resource.json",
HttpVersion.HTTP1_1,
new HttpMessage(
new HttpHeaders()
{
new HttpHeader("User-Agent", "Solace NT"),
},
new HttpBody(
"{\r\n \"message\": \"hello, world!\"\r\n}"
)
)
);
var stream1 = new MemoryStream();
await mock_session_factory2.SimulateConnection(stream1, port : 1);
var session1 = await server1.SendRequest("localhost", 2, request1);
session1.OnUnhandledException += e => { server1_exception = e; server1_err_spot = 5; return(Task.CompletedTask); };
session1.OnGET += (resp, session) =>
{
got_response = true;
return(Task.CompletedTask);
};
await Task.Delay(5_000);
server1.Stop();
server2.Stop();
if (!(server1_exception is null))
{
Write($"Server1 Exception, Spot {server1_err_spot}: " + server1_exception.ToString());
throw server1_exception;
}
if (!(server2_exception is null))
{
Write($"Server2 Exception, Spot {server2_err_spot}: " + server2_exception.ToString());
throw server2_exception;
}
Assert.True(got_request);
Assert.True(got_response);
}
public MockTcpSessionFactory(LibNetworkConfig config)
{
Config = config;
running = false;
streams = new Dictionary <int, MemoryStream>();
}
static async Task Main(string[] args)
{
Console.WriteLine("Starting test server...");
int port = 4988;
/*
* while (true)
* {
* Console.Write("PORT> ");
* var port_str = Console.ReadLine();
* var success = int.TryParse(port_str, out port);
* if (success && port > 0)
* {
* Console.WriteLine($"PORT SET TO {port}.");
* break;
* }
* else
* {
* Console.WriteLine($"INVALID INPUT '{port_str}'. PORT MUST BE A POSITIVE INTEGER.");
* }
* }
* //*/
var config = new LibNetworkConfig()
{
Port = port,
Http = new HttpConfig()
{
SessionTimeout = TimeSpan.FromSeconds(20),
},
};
var server = new HttpServer(config);
server.OnNewConnection += http_session =>
{
http_session.OnUnhandledException += e =>
{
Console.WriteLine($"SESSION UNHANDLED EXCEPTION: {e}");
return(Task.CompletedTask);
};
http_session.OnInvalidRequest += (req, session) =>
{
Console.WriteLine($"INVALID REQUEST {req}");
return(Task.CompletedTask);
};
http_session.OnTimeoutDisconnect += session =>
{
Console.WriteLine("SESSION TIMED OUT");
return(Task.CompletedTask);
};
http_session.OnAnyValidRequest += (req, session) =>
{
Console.WriteLine($"GOT REQUEST {req}");
return(Task.CompletedTask);
};
return(Task.CompletedTask);
};
server.OnUnhandledException += e =>
{
Console.WriteLine($"SERVER UNHANDLED EXCEPTION: {e}");
return(Task.CompletedTask);
};
server.OnSessionException += e =>
{
Console.WriteLine($"SERVER SESSION EXCEPTION: {e}");
return(Task.CompletedTask);
};
server.OnSocketException += num =>
{
Console.WriteLine($"SERVER SOCKET ERROR: {num}");
return(Task.CompletedTask);
};
await server.StartAsync();
Console.WriteLine("END OF EXECUTION.");
Console.ReadLine();
}
