Add WebServer status event (#241)

Author: Ellerbach

README.md

@@ -196,7 +196,6 @@ With the previous example the following happens:
 
 All up, this is an example to show how to use authentication, it's been defined to allow flexibility.
 
-
 ## Managing incoming queries thru events
 
 Very basic usage is the following:
@@ -394,6 +393,20 @@ using (WebServer server = new WebServer(443, HttpProtocol.Https)
 
 You can of course use the routes as defined earlier. Both will work, event or route with the notion of controller.
 
+## WebServer status
+
+It is possible to subscribe to an event to get the WebServer status. That can be useful to restart the server, put in place a retry mechanism or equivalent.
+
+```csharp
+server.WebServerStatusChanged += WebServerStatusChanged;
+
+private static void WebServerStatusChanged(object obj, WebServerStatusEventArgs e)
+{
+    // Do whatever you need like restarting the server
+    Debug.WriteLine($"The web server is now {(e.Status == WebServerStatus.Running ? "running" : "stopped" )}");
+}
+```
+
 ## Feedback and documentation
 
 For documentation, providing feedback, issues and finding out how to contribute please refer to the [Home repo](https://github.com/nanoframework/Home).

nanoFramework.WebServer.FileSystem/nanoFramework.WebServer.FileSystem.nfproj

@@ -68,6 +68,12 @@
     <Compile Include="..\nanoFramework.WebServer\WebServer.cs">
       <Link>WebServer.cs</Link>
     </Compile>
+    <Compile Include="..\nanoFramework.WebServer\WebServerStatus.cs">
+      <Link>WebServerStatus.cs</Link>
+    </Compile>
+    <Compile Include="..\nanoFramework.WebServer\WebServerStatusEventArgs.cs">
+      <Link>WebServerStatusEventArgs.cs</Link>
+    </Compile>
     <None Include="..\key.snk" />
   </ItemGroup>
   <ItemGroup>

nanoFramework.WebServer/WebServer.cs

@@ -43,7 +43,7 @@ public class WebServer : IDisposable
 
         #region internal objects
 
-        private bool _cancel = false;
+        private bool _cancel = true;
         private Thread _serverThread = null;
         private readonly ArrayList _callbackRoutes;
         private readonly HttpListener _listener;
@@ -92,6 +92,11 @@ public SslProtocols SslProtocols
         /// </summary>
         public string ApiKey { get; set; }
 
+        /// <summary>
+        /// Gets a value indicating whether the web server is running.
+        /// </summary>
+        public bool IsRunning => !_cancel;
+
         #endregion
 
         #region Param
@@ -191,7 +196,7 @@ private void RegisterControllers(Type[] controllers)
             {
                 return;
             }
-            
+
             foreach (var controller in controllers)
             {
                 var controlAttribs = controller.GetCustomAttributes(true);
@@ -216,7 +221,7 @@ private void RegisterControllers(Type[] controllers)
                         {
                             continue;
                         }
-                        
+
                         var callbackRoutes = new CallbackRoutes
                         {
                             Route = ((RouteAttribute)attrib).Route,
@@ -330,6 +335,8 @@ private Authentication ExtractAuthentication(string strAuth)
         /// <summary>
         /// Delegate for the CommandReceived event.
         /// </summary>
+        /// <param name="obj">The source of the event.</param>
+        /// <param name="e">A WebServerEventArgs that contains the event data.</param>
         public delegate void GetRequestHandler(object obj, WebServerEventArgs e);
 
         /// <summary>
@@ -338,6 +345,18 @@ private Authentication ExtractAuthentication(string strAuth)
         /// </summary>
         public event GetRequestHandler CommandReceived;
 
+        /// <summary>
+        /// Represents the method that will handle the WebServerStatusChanged event of a WebServer.
+        /// </summary>
+        /// <param name="obj">The source of the event.</param>
+        /// <param name="e">A WebServerStatusEventArgs that contains the event data.</param>
+        public delegate void WebServerStatusHandler(object obj, WebServerStatusEventArgs e);
+
+        /// <summary>
+        /// Occurs when the status of the WebServer changes.
+        /// </summary>
+        public event WebServerStatusHandler WebServerStatusChanged;
+
         #endregion
 
         #region Public and private methods
@@ -353,8 +372,10 @@ public bool Start()
             }
 
             bool bStarted = true;
+#if DEBUG
             // List Ethernet interfaces, so we can determine the server's address
             ListInterfaces();
+#endif
             // start server           
             try
             {
@@ -368,6 +389,12 @@ public bool Start()
                 _cancel = true;
                 bStarted = false;
             }
+
+            if (bStarted)
+            {
+                WebServerStatusChanged?.Invoke(this, new WebServerStatusEventArgs(WebServerStatus.Running));
+            }
+
             return bStarted;
         }
 
@@ -380,7 +407,8 @@ public void Stop()
             Thread.Sleep(100);
             _serverThread.Abort();
             _serverThread = null;
-            Debug.WriteLine("Stopped server in thread ");
+            // Event is generate in the running thread
+            Debug.WriteLine("Stopped server in thread ");            
         }
 
         /// <summary>
@@ -487,106 +515,117 @@ public static void SendFileOverHTTP(HttpListenerResponse response, string fileNa
 
         private void StartListener()
         {
-            _listener.Start();
-            while (!_cancel)
+            try
             {
-                HttpListenerContext context = _listener.GetContext();
-                if (context == null)
-                {
-                    return;
-                }
-
-                new Thread(() =>
+                _listener.Start();
+                while (!_cancel)
                 {
-                    //This is for handling with transitory or bad requests
-                    if (context.Request.RawUrl == null)
+                    HttpListenerContext context = _listener.GetContext();
+                    if (context == null)
                     {
                         return;
                     }
 
-                    // Variables used only within the "for". They are here for performance reasons
-                    bool mustAuthenticate;
-                    bool isAuthOk;
-                    bool isRoute = false;
-
-                    foreach (CallbackRoutes route in _callbackRoutes)
+                    new Thread(() =>
                     {
-                        if (!IsRouteMatch(route, context.Request.HttpMethod, context.Request.RawUrl))
+                        //This is for handling with transitory or bad requests
+                        if (context.Request.RawUrl == null)
                         {
-                            continue;
+                            return;
                         }
 
-                        isRoute = true;
-
-                        // Check auth first
-                        mustAuthenticate = route.Authentication != null && route.Authentication.AuthenticationType != AuthenticationType.None;
-                        isAuthOk = !mustAuthenticate;
+                        // Variables used only within the "for". They are here for performance reasons
+                        bool mustAuthenticate;
+                        bool isAuthOk;
+                        bool isRoute = false;
 
-                        if (mustAuthenticate)
+                        foreach (CallbackRoutes route in _callbackRoutes)
                         {
-                            if (route.Authentication.AuthenticationType == AuthenticationType.Basic)
+                            if (!IsRouteMatch(route, context.Request.HttpMethod, context.Request.RawUrl))
                             {
-                                var credSite = route.Authentication.Credentials ?? Credential;
-                                var credReq = context.Request.Credentials;
-
-                                isAuthOk = credReq != null
-                                    && (credSite.UserName == credReq.UserName)
-                                    && (credSite.Password == credReq.Password);
+                                continue;
                             }
-                            else if (route.Authentication.AuthenticationType == AuthenticationType.ApiKey)
-                            {
-                                var apikeySite = route.Authentication.ApiKey ?? ApiKey;
-                                var apikeyReq = GetApiKeyFromHeaders(context.Request.Headers);
 
-                                isAuthOk = apikeyReq != null
-                                    && apikeyReq == apikeySite;
-                            }
-                        }
+                            isRoute = true;
 
-                        if (!isAuthOk)
-                        {
-                            if (route.Authentication != null &&
-                                route.Authentication.AuthenticationType == AuthenticationType.Basic)
+                            // Check auth first
+                            mustAuthenticate = route.Authentication != null && route.Authentication.AuthenticationType != AuthenticationType.None;
+                            isAuthOk = !mustAuthenticate;
+
+                            if (mustAuthenticate)
                             {
-                                context.Response.Headers.Add("WWW-Authenticate",
-                                    $"Basic realm=\"Access to {route.Route}\"");
+                                if (route.Authentication.AuthenticationType == AuthenticationType.Basic)
+                                {
+                                    var credSite = route.Authentication.Credentials ?? Credential;
+                                    var credReq = context.Request.Credentials;
+
+                                    isAuthOk = credReq != null
+                                        && (credSite.UserName == credReq.UserName)
+                                        && (credSite.Password == credReq.Password);
+                                }
+                                else if (route.Authentication.AuthenticationType == AuthenticationType.ApiKey)
+                                {
+                                    var apikeySite = route.Authentication.ApiKey ?? ApiKey;
+                                    var apikeyReq = GetApiKeyFromHeaders(context.Request.Headers);
+
+                                    isAuthOk = apikeyReq != null
+                                        && apikeyReq == apikeySite;
+                                }
                             }
 
-                            context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
-                            context.Response.ContentLength64 = 0;
+                            if (!isAuthOk)
+                            {
+                                if (route.Authentication != null &&
+                                    route.Authentication.AuthenticationType == AuthenticationType.Basic)
+                                {
+                                    context.Response.Headers.Add("WWW-Authenticate",
+                                        $"Basic realm=\"Access to {route.Route}\"");
+                                }
+
+                                context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
+                                context.Response.ContentLength64 = 0;
+
+                                HandleContextResponse(context);
+                                return;
+                            }
 
+                            InvokeRoute(route, context);
                             HandleContextResponse(context);
-                            return;
                         }
 
-                        InvokeRoute(route, context);
-                        HandleContextResponse(context);
-                    }
-
-                    if (!isRoute)
-                    {
-                        if (CommandReceived != null)
+                        if (!isRoute)
                         {
-                            // Starting a new thread to be able to handle a new request in parallel
-                            CommandReceived.Invoke(this, new WebServerEventArgs(context));
-                        }
-                        else
-                        {
-                            context.Response.StatusCode = (int)HttpStatusCode.NotFound;
-                            context.Response.ContentLength64 = 0;
+                            if (CommandReceived != null)
+                            {
+                                // Starting a new thread to be able to handle a new request in parallel
+                                CommandReceived.Invoke(this, new WebServerEventArgs(context));
+                            }
+                            else
+                            {
+                                context.Response.StatusCode = (int)HttpStatusCode.NotFound;
+                                context.Response.ContentLength64 = 0;
+                            }
+
+                            HandleContextResponse(context);
                         }
+                    }).Start();
 
-                        HandleContextResponse(context);
-                    }
-                }).Start();
+                }
 
+                if (_listener.IsListening)
+                {
+                    _listener.Stop();
+                }
             }
-            if (_listener.IsListening)
+            catch
             {
-                _listener.Stop();
-            }
+                // If we are here then set the server state to not running
+                _cancel = true;
+            }            
+
+            WebServerStatusChanged?.Invoke(this, new WebServerStatusEventArgs(WebServerStatus.Stopped));
         }
-        
+
         /// <summary>
         /// Checks if route matches called resource.
         /// For internal use only.
@@ -601,14 +640,14 @@ public static bool IsRouteMatch(CallbackRoutes route, string method, string rawU
             {
                 return false;
             }
-            
+
             var urlParam = rawUrl.IndexOf(ParamStart);
             var incForSlash = route.Route.IndexOf('/') == 0 ? 0 : 1;
             var rawUrlToCompare = route.CaseSensitive ? rawUrl : rawUrl.ToLower();
             var routeToCompare = route.CaseSensitive ? route.Route : route.Route.ToLower();
             bool isFound;
-            
-            if (urlParam > 0 )
+
+            if (urlParam > 0)
             {
                 isFound = urlParam == routeToCompare.Length + incForSlash;
             }
@@ -771,6 +810,6 @@ protected virtual void Dispose(bool disposing)
             }
         }
 
-#endregion
+        #endregion
     }
 }

nanoFramework.WebServer/WebServerStatus.cs

@@ -0,0 +1,21 @@
+// Copyright (c) 2020 Laurent Ellerbach and the project contributors
+// See LICENSE file in the project root for full license information.
+
+namespace nanoFramework.WebServer
+{
+    /// <summary>
+    /// Represents the status of the server.
+    /// </summary>
+    public enum WebServerStatus
+    {
+        /// <summary>
+        /// The server is stopped.
+        /// </summary>
+        Stopped,
+
+        /// <summary>
+        /// The server is running.
+        /// </summary>
+        Running,
+    }
+}