public virtual string Start()
{
string ret = null;
LOG.Debug("Starting HTTP server listening on port {0}...", Port);
try
{
Listener.Start();
int timeoutSeconds = 3;
bool isListening = CheckIsListening(timeoutSeconds);
if (!isListening)
{
LOG.Error("Failed to start HTTP server listening on port {0}.", Port);
return("Failed to start HTTP server");
}
LOG.Debug("Calling Listener.BeginGetContext from main thread...");
RequestProcessorParameter arguments =
new RequestProcessorParameter(this.Listener, this.RequestHandler);
Listener.BeginGetContext(ProcessHttpRequest, arguments);
LOG.Debug("Continuing main thread after Listener.BeginGetContext...");
LOG.Debug("HTTP server listening on port {0} has started.", Port);
return("OK");
}
catch (Exception e)
{
LOG.Error(e, "Failed to start HTTP server listening on port {0}.", Port);
return("Failed to start HTTP server: " + e.Message);
}
}
public void Start()
{
Listener.Start();
Listener.BeginGetContext(OnConnection, null !);
DB.ConnectionAsync().GetAwaiter().GetResult();
}
public void Start()
{
Logger.Debug("starting HttpListener");
StopNow = false;
Listener.Start();
Listener.BeginGetContext(ListenerCallback, Listener);
}
// Listens for new requests and enqueues them
private void Listen()
{
while (Listener.IsListening)
{
// Accept new connection context
var Context = Listener.BeginGetContext((IAsyncResult Result) =>
{
try
{
// Lock our context queue to prevent race conditions
lock (ContextQueue)
{
// Add new connection context to our context queue
ContextQueue.Enqueue(Listener.EndGetContext(Result));
// Signal that a context is ready to be accepted
ReadyEvent.Set();
}
}
catch { }
}, null);
// Wait for exit
if (WaitHandle.WaitAny(new[] { StopEvent, Context.AsyncWaitHandle }) == 0)
{
return;
}
}
}
// This task is ran Asynchronously each time a request is made
public void OnContextRequest(IAsyncResult result)
{
try
{
//The GetContext method blocks while waiting for a request.
//We use EndGetContext and BeginGetContext instead.
//As soon as we are done with the last context, we should be listening for the next.
//That way we can reply to many at the same time.
Context = Listener.EndGetContext(result);
Listener.BeginGetContext(OnContextRequest, Listener);
//Get the specifics of the request and extract the target file/directory.
string target = context.Request.RawUrl;
string path = TargetDecoder(target);
DetermineResponse(path);
}
catch (HttpListenerException e)
{
// If a connection is terminated mid-download, this will cause an exception.
// We generally want to avoid that, as this is not fatal.
Logger.Log(e.Message);
Logger.Log("Data Stream Terminated early!");
}
catch (Exception)
{
// Othervise douse everything in gasoline and light a match.
Logger.Log("Listener Stopped, Stopping Thread");
throw;
}
}
// Loop here to begin processing of new requests.
private void Listen(object state)
{
while (Listener.IsListening)
{
if (Listener == null)
{
return;
}
try
{
Listener.BeginGetContext(ListenerCallback, Listener);
_listenForNextRequest.WaitOne();
}
catch (Exception ex)
{
_log.Error("Error occurred while host is listening", ex,
new Dictionary <string, string>()
{
{ "ErrorCode", "FXD300051" }
});
return;
}
if (Listener == null)
{
return;
}
}
}
// Loop here to begin processing of new requests.
private void Listen(object state, int index)
{
while (IsListening)
{
if (Listener == null)
{
return;
}
try
{
Listener.BeginGetContext(c => ListenerCallback(c, index), Listener);
_autoResetEvents[index].WaitOne();
}
catch (Exception ex)
{
_logger.Error("Listen()", ex);
return;
}
if (Listener == null)
{
return;
}
}
}
// Loop here to begin processing of new requests.
private void Listen(object state)
{
while (IsListening)
{
if (Listener == null)
{
return;
}
try
{
Listener.BeginGetContext(ListenerCallback, Listener);
listenForNextRequest.WaitOne();
}
catch (Exception ex)
{
log.Error("Listen()", ex);
return;
}
if (Listener == null)
{
return;
}
}
}
private void ListenerImplementation()
{
var res = Listener.BeginGetContext(new AsyncCallback(ListenerCallback), Listener);
if (!res.AsyncWaitHandle.WaitOne(1000))
{
res.AsyncWaitHandle.Close();
}
}
private void GetServerCallback <TContext>(IAsyncResult ar) where TContext : Context
{
var application = ar.AsyncState as IHttpApplication <TContext>;
HttpListenerContext httpListenerContext = Listener.EndGetContext(ar);
//if (httpListenerContext.Request.IsWebSocketRequest)
//{
// var socket = httpListenerContext.AcceptWebSocketAsync("gutsmvc").GetAwaiter().GetResult().WebSocket;
// while (true)
// {
// ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]);
// WebSocketReceiveResult result = socket.ReceiveAsync(buffer, CancellationToken.None).GetAwaiter().GetResult();
// if (socket.State == WebSocketState.Open)
// {
// string message = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
// string returnMessage = "You send :" + message + ". at" + DateTime.Now.ToLongTimeString();
// buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(returnMessage));
// socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None).GetAwaiter().GetResult();
// }
// else
// {
// break;
// }
// }
//}
Listener.BeginGetContext(GetServerCallback <TContext>, application);
var t = Task.Factory.StartNew(() =>
{
IHttpListenerContextFeature feature = new HttpListenerContextFeature(httpListenerContext, Listener);
IFeatureCollection contextFeatures = new FeatureCollection(Services)
.Set <IHttpRequestFeature>(feature.RequestFeature)
.Set <IHttpResponseFeature>(feature.ResponseFeature)
.Set <IWebSocketFeature>(feature.WebSocketFeature);
TContext context = application.CreateContext(contextFeatures);
//await application.ProcessRequestAsync(context).ConfigureAwait(false).GetAwaiter().GetResult();
//application.ProcessRequestAsync(context).ConfigureAwait(false).GetAwaiter()
//.OnCompleted(() => context.Dispose());
application.ProcessRequestAsync(context).ConfigureAwait(false).GetAwaiter().GetResult();
context.Dispose();
//return context;
});
//(t.ConfigureAwait(false).GetAwaiter().GetResult()).Dispose();
}
public void StartListening()
{
if (!Listener.IsListening)
{
try
{
Listener.Start();
OnListenerStart();
Listener.BeginGetContext(new AsyncCallback(GetContextCallback), Listener);
}
catch (HttpListenerException ex)
{
Logger.Get <WPDListener>().LogTrace(ex.ToString());
}
}
}
private void OnConnection(IAsyncResult ar)
{
try {
Listener.BeginGetContext(OnConnection, null !);
var context = Listener.EndGetContext(ar);
context.Response.ContentEncoding = Encoding.UTF8;
context.Response.AddHeader("Server", "QuizHub/1.0");
context.Response.AddHeader("Access-Control-Allow-Origin", "*");
try {
switch (context.Request.HttpMethod)
{
case "GET":
OnGET(context);
break;
case "POST":
OnPOST(context);
break;
case "OPTIONS":
context.Response.Close();
break;
default:
context.Response.Abort();
break;
}
} catch (JsonableException ex) {
Answer.Json(context, Json.Error(ex));
} catch (ArgumentException ex) {
Answer.Json(context,
ex.StackTrace?.Contains("Json.JavaScriptReader") ?? false
? Json.Error(new Ex04_WrongJson())
: Json.Error(new Ex01_Unexpected(ex)));
} catch (Exception ex) {
Answer.Json(context, Json.Error(new Ex01_Unexpected(ex)));
}
} catch (Exception ex) { Console.WriteLine("ERR: {0}\n\n{1}", ex.Message, ex.StackTrace); }
}
private void ListenerCallback(IAsyncResult result)
{
// fetch the context
var context = Listener.EndGetContext(result);
// get ready for the next request
Listener.BeginGetContext(ListenerCallback, Listener);
try
{
HandleRequest(context);
}
catch (Exception exc)
{
Logger.Error("exception thrown while handling HTTP connection", exc);
}
finally
{
context.Response.Close();
}
}
/// <summary>
///
/// </summary>
/// <param name="result"></param>
void GetContextCallback(IAsyncResult result)
{
lock (locker)
{
if (Listener == null || Listener.IsListening == false)
{
return;
}
HttpListenerContext context = Listener.EndGetContext(result);
logrequest(context);
try
{
if (IsAuthenticated(context))
{
string url = context.Request.Url.LocalPath;
if (Enable)
{
if (url == "/")
{
context.Response.Redirect(Config?.DefaultUrl);
}
else
{
wasRestCallBack cb = FindRest(url);
if (cb != null)
{
StringBuilder sb = new System.Text.StringBuilder();
cb(context, sb);
context.Response.ContentType = FileContentType(".json");
Render(Encode(sb.ToString()), context.Response);
}
else
{
url = Config?.DefaultDir + url;
if (url.Length > 1 && File.Exists(url.Substring(1)))
{
/** Es un fichero lo envio... */
string file = url.Substring(1);
string ext = Path.GetExtension(file).ToLowerInvariant();
context.Response.ContentType = FileContentType(ext);
ProcessFile(context.Response, file);
}
else
{
context.Response.StatusCode = 404;
}
}
}
}
else
{
// Render(Encode(DisableCause), context.Response);
// context.Response.StatusCode = 503;
// context.Response.Redirect("/noserver.html");
context.Response.ContentType = FileContentType(".html");
ProcessFile(context.Response, (Config?.DefaultDir + "/disabled.html").Substring(1), "{{cause}}", DisableCause);
}
}
}
catch (Exception x)
{
Logger.Exception <WebServerBase>(x);
context.Response.StatusCode = 500;
// Todo. Render(Encode(x.Message), context.Response);
}
finally
{
context.Response.Close();
if (Listener != null && Listener.IsListening)
{
Listener.BeginGetContext(new AsyncCallback(GetContextCallback), null);
}
}
}
}
public void Start()
{
Listener.Start();
Listener.BeginGetContext(OnRequest, Listener);
}
private void ProcessRequest()
{
var result = Listener.BeginGetContext(HandleRequest, Listener);
result.AsyncWaitHandle.WaitOne();
}
public void Start()
{
Listener.Start();
Listener.BeginGetContext(new AsyncCallback(GetContextCallback), Listener);
}
private void BeginWait()
{
var state = new object();
Listener.BeginGetContext(OnContextReceived, state);
}
public void Start()
{
// Start listener and accept Http contexts.
Listener.Start();
Listener.BeginGetContext(new AsyncCallback(HandleGetContext), this);
}