Exemple #1
0
 private void RestServer_OnRestServerStopped(object sender, OnRestServerStoppedEventArgs e)
 {
     OnRestServerStopped?.Invoke(this, e);
 }
Exemple #2
0
        /// <summary>
        /// Will run the rest server
        /// </summary>
        public async void Run()
        {
            //Intialize endpoint rest jobs
            //foreach (RestEndpoint endpoint in m_Endpoints)
            //{
            //    endpoint.InitializeRestJob(m_CommManager);
            //}

            List <string> uriPrefixes = new List <string>();

            uriPrefixes.Add(m_PrefixAddress);
            uriPrefixes.AddRange(m_Endpoints.Select(c =>
            {
                if (c.IsQueryAddress)
                {
                    return(m_PrefixAddress + c.PreQueryAddress);
                }
                else if (c.IsTemplateAddress)
                {
                    return(m_PrefixAddress + c.PreTemplateAddress);
                }
                else
                {
                    return(m_PrefixAddress + c.Address);
                }
            }));

            //insure the uri prefixes have ending slashes
            for (int i = 0; i < uriPrefixes.Count; i++)
            {
                if (uriPrefixes[i].Last() != '/' && uriPrefixes[i].Last() != '\\')
                {
                    uriPrefixes[i] += "/";
                }
            }

            m_IsServerRunning = true;

            TraceWriteLine($"Rest Server {m_ServerName} adding listener bindings");
            // Add the server bindings:
            foreach (var prefix in uriPrefixes)
            {
                TraceWriteLine($"Rest Server {m_ServerName} adding listener binding for prefix {prefix}");
                listener.Prefixes.Add(prefix);
            }

            if (m_UseBasicAuth)
            {
                listener.AuthenticationSchemes = AuthenticationSchemes.Basic;
            }

            TraceWriteLine($"Rest Server {m_ServerName} initializing listener");
            bool retryStart = false;
            int  retryCount = 0;
            int  maxRetry   = 15;

            do
            {
                try
                {
                    listener.Start();
                    retryStart = false;
                }
                catch (HttpListenerException ex)
                {
                    TraceWriteLine($"Rest Server {m_ServerName} failed to start with exception {ex.Message}");
                    if (ex.Message == "Access is denied")
                    {
                        TraceWriteLine($"Rest Server {m_ServerName} failed to start due to lack of permissions, restart the application as Administrator.");
                        retryStart = false;
                        OnRestServerStopped?.Invoke(this, new OnRestServerStoppedEventArgs(m_RestServerData));
                        return;
                    }
                    else if (retryCount < maxRetry)
                    {
                        retryStart = true;
                        retryCount++;
                        TraceWriteLine($"Retrying Rest Server {m_ServerName} start, retry count {retryCount}");
                        Thread.Sleep(1000);
                    }
                    else
                    {
                        TraceWriteLine($"Retried Rest Server {m_ServerName} start {retryCount} times, throwing failed to start exception");
                        retryStart = false;
                        //throw new RestServerDataException(m_RestServerData, "", $"Rest Server {m_ServerName} failed to start after {retryCount} retries.\n{ex.ToString()}");
                        OnRestServerStopped?.Invoke(this, new OnRestServerStoppedEventArgs(m_RestServerData));
                        return;
                    }
                }
            } while (retryStart);
            TraceWriteLine($"Rest Server {m_ServerName} initialized listener");

            //Accept connections:
            //1. Higher values mean more connections can be maintained yet at a
            //   much slower average response time; fewer connections will be rejected.
            //2. Lower values mean less connections can be maintained yet at a
            //   much faster average response time; more connections will be rejected.
            sem = new Semaphore(m_ConcurrentConnections, m_ConcurrentConnections);
            try
            {
                await RunServer();
            }
            catch (Exception ex)
            {
                TraceWriteLine(ex.ToString());
            }
            finally
            {
                m_IsServerRunning = false;
                if (!m_IsCloseRequested)
                {
                    listener.Stop();
                }
            }

            OnRestServerStopped?.Invoke(this, new OnRestServerStoppedEventArgs(m_RestServerData));
        }