static void Main() { Console.Title = "Samples.CustomChecks.3rdPartySystem"; Console.WriteLine("Press enter key to toggle the server to return a error or success"); Console.WriteLine("Press any key to exit"); using (listener = new HttpListener()) { listener.Prefixes.Add("http://localhost:57789/"); listener.Start(); listener.BeginGetContext(ListenerCallback, listener); while (true) { ConsoleKeyInfo key = Console.ReadKey(); Console.WriteLine(); if (key.Key != ConsoleKey.Enter) { return; } listener.Close(); if (isReturningOk) { Console.WriteLine("\r\nCurrently returning success"); } else { Console.WriteLine("\r\nCurrently returning error"); } isReturningOk = !isReturningOk; } } }
private void stopToolStripMenuItem_Click(Object sender, EventArgs e) { listener?.Stop(); listener?.Close(); stopToolStripMenuItem.Enabled = false; startToolStripMenuItem.Enabled = true; }
public void Dispose() { try { _listener?.Close(); _serverThread?.Dispose(); } catch { } }
public static async Task <string> Authorize(params string[] scopes) { // Make sure we close before we try again listener?.Close(); listener = new HttpListener(); listener.Prefixes.Add($"http://localhost:{Port}/"); listener.Start(); string scopeStr = string.Join(" ", scopes); Process.Start( $"https://id.twitch.tv/oauth2/authorize?client_id={ClientID}" + $"&redirect_uri=http%3A%2F%2Flocalhost%3A{Port}" + $"&response_type=token" + $"&scope={scopeStr}"); while (listener.IsListening) { var context = await listener.GetContextAsync(); var request = context.Request; if (request.HttpMethod == "POST") { string text; using (var reader = new StreamReader(request.InputStream, request.ContentEncoding)) { text = await reader.ReadToEndAsync(); } listener.Close(); var keyValuePairs = HttpUtility.UrlDecode(text) .Split('&') .Select(kv => kv.Split('=')) .ToDictionary(kv => kv[0].Replace("#", ""), kv => kv[1]); if (keyValuePairs.TryGetValue("access_token", out var accessToken)) { return(accessToken); } } else { var response = context.Response; byte[] buffer = Encoding.UTF8.GetBytes(HttpRedirect); response.ContentLength64 = buffer.Length; var output = response.OutputStream; await output.WriteAsync(buffer, 0, buffer.Length); output.Close(); } } return(null); }
public void Dispose() { _httpListener?.Close(); _httpListener = null; (_router as IDisposable)?.Dispose(); _router = null; }
protected virtual void Dispose(bool disposing) { if (!disposing) { return; } if (Interlocked.Increment(ref _disposeCount) != 1) { return; } Stop(); lock (_queueStatusProviders) { while (!_queueStatusProviders.IsEmpty) { _queueStatusProviders.TryTake(out _); } } _httpListener?.Close(); _cancelTokenSource?.Dispose(); }
//public string Wait(string content, CancellationToken token) //{ // while (!received.Contains(content))// // { // if (token.Stop) return null; // Task.Delay(100).Wait(); // } // return received; //} private void Listen() { try { _listener?.Close(); _listener = new HttpListener(); _listener.Prefixes.Add("http://localhost:" + _port + "/"); _listener.Start(); while (true) { if (_stopServer) { _listener.Close(); return; } HttpListenerContext context = _listener.GetContext(); Process(context); } } catch (Exception ex) { if (IsStarted) { _listener?.Close(); Listen(); } } }
public Task Stop() { _disposeCancellationTokenSource.Cancel(); _listener?.Close(); return(Task.CompletedTask); }
public void Listen() { try { _listener?.Close(); _listener = new HttpListener(); _listener.Prefixes.Add("http://*:" + _port + "/"); _listener.Start(); while (true) { if (_stopServer) { _listener.Close(); return; } HttpListenerContext context = _listener.GetContext(); Process(context); } } catch (Exception ex) { Console.WriteLine(ex.ToString()); if (IsStarted) { _listener?.Close(); Listen(); } } }
protected override void Dispose(bool isDisposing) { if (_isDisposed) { return; } if (isDisposing) { CloseAsync().GetAwaiter().GetResult(); _webSocket?.Dispose(); _httpListener?.Close(); } _isDisposed = true; }
protected virtual void Dispose(bool disposing) { if (disposing) { _httpListener?.Stop(); _httpListener?.Close(); } }
public void Stop() { Listener?.Close(); Listener?.Stop(); Listener = null; isStarted = false; AirportStatUtils.AirportStatsLogger(Log.FromPool("Listener Stopped").WithCodepoint()); }
public void Close() { clientWaitDisposable?.Dispose(); httpListener?.Close(); clientDisposables.ForEach(x => x.Dispose()); clientDisposables.Clear(); clients.ForEach(x => x.Dispose()); clients.Clear(); }
/// <summary> /// Stops listening for incoming connections. /// </summary> public void StopListening() { Listening = false; ReleaseClients(); httpListener?.Stop(); httpListener?.Close(); httpListener = null; nat?.DeletePortMapAsync(portMap); }
private static void StopHttpShow() { try { httpListener?.Stop(); } catch { } httpListener?.Close(); }
public void Dispose() { Display?.Dispose(); Display = null; webListener?.Stop(); webListener?.Close(); webListener = null; }
public void Stop() { // TODO: thread safety _stop = true; _listener?.Stop(); _listener?.Close(); _handler?.Dispose(); _listener = null; SetStatus(HttpAsyncHostStatus.Initialised); }
protected virtual void Dispose(bool disposing) { if (!disposing) { return; } _listener?.Close(); _acceptSemaphore?.Dispose(); }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { if (disposing) { StopAsync().Wait(); _httpListener?.Close(); _httpListener = null; } base.Dispose(disposing); }
public void Dispose() { if (_isDisposed) { return; } _isDisposed = true; _httpListener?.Close(); }
/// <summary> /// Releases unmanaged and - optionally - managed resources. /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { if (disposing && !_disposedValue) { Logger.Trace($"Disposing {GetType().Name}"); AsyncContext.Run(() => StopAsync()); _httpListener?.Close(); _httpListener = null; } _disposedValue = true; }
public void Stop() { // shutdown stop.Set(); listener?.Close(); thread?.Join(); // reset stop.Reset(); listener = null; thread = null; }
public void Disconnect() { try { _listener?.Stop(); _listener?.Close(); } catch (Exception ex) { Log.Out("Caught exception when disconnecting: {0}", ex.ToString()); } }
private static void StartHttpShow() { try { httpListener = new HttpListener(); httpListener.Prefixes.Add("http://127.0.0.1:44100/"); httpListener.Start(); httpListener.BeginGetContext(HttpShowServe, null); } catch { httpListener?.Close(); } }
public void StopMining() { Program.Print("[INFO] Master instance stopping..."); m_isOngoing = false; NetworkInterface.OnGetMiningParameterStatus -= NetworkInterface_OnGetMiningParameterStatus; NetworkInterface.OnNewChallenge -= NetworkInterface_OnNewChallenge; NetworkInterface.OnNewTarget -= NetworkInterface_OnNewTarget; NetworkInterface.OnNewDifficulty -= NetworkInterface_OnNewDifficulty; NetworkInterface.OnStopSolvingCurrentChallenge -= NetworkInterface_OnStopSolvingCurrentChallenge; m_Listener?.Stop(); m_Listener?.Close(); }
static void Main () { HttpListener listener = new HttpListener (); listener.IgnoreWriteExceptions = true; listener.Prefixes.Add ("http://*:8081/"); listener.Start (); listener.BeginGetContext (RequestHandler, listener); while (true) { Thread.Sleep (250); if (File.Exists ("stop-server.tmp")) break; } listener.Close (); File.Create ("finish-server.tmp").Close (); }
internal void Stop() { Console.WriteLine("TListener - Stop requested"); if (!Tokenizer.IsCancellationRequested) { Tokenizer.Cancel(); } if (_listener.IsListening) { _listener.Stop(); } ClearListeners(); _listener?.Close(); }
/// <summary> /// サーバー停止 /// </summary> public void StopServer() { try { listener?.Close(); } catch (Exception e) { //Do noting } finally { thread?.Join(); } }
/// <summary> /// Stopps the current HTTP server /// </summary> public void Stop() { try { if (_listener?.IsListening ?? false) { _listener?.Stop(); } _listener?.Close(); } finally { acceptconnections = false; } }
private bool disposedValue = false; // To detect redundant calls /// <summary> /// Disposes the server. /// </summary> /// <param name="disposing"></param> protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { httpListener?.Stop(); httpListener?.Close(); } // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below. // TODO: set large fields to null. disposedValue = true; } }
/// <summary> /// サーバー停止 /// </summary> private void StopServerInternal() { Debug.Log("[SEDSS Server] Stop Internal."); try { listener?.Close(); } catch (Exception e) { //Do noting } finally { thread?.Join(); } }
public void StopService() { try { if (_listener.IsListening) { _listener?.Stop(); _listener?.Abort(); _listener?.Close(); } } catch (Exception e) { Console.WriteLine(e); } }
static UrlPrefix() { // Find a URL prefix that is not in use on this machine *and* uses a port that's not in use. // Once we find this prefix, keep a listener on it for the duration of the process, so other processes // can't steal it. Guid processGuid = Guid.NewGuid(); for (int port = 1024; port <= IPEndPoint.MaxPort; port++) { string prefix = $"http://localhost:{port}/{processGuid:N}/"; var listener = new HttpListener(); try { listener.Prefixes.Add(prefix); listener.Start(); s_processPrefixListener = listener; s_processPrefix = prefix; break; } catch (Exception e) { // can't use this prefix listener.Close(); // Remember the exception for later s_processPrefixException = e; // If this is not an HttpListenerException, something very wrong has happened, and there's no point // in trying again. if (!(e is HttpListenerException)) break; } } // At this point, either we've reserved a prefix, or we've tried everything and failed. If we failed, // we've saved the exception for later. We'll defer actually *throwing* the exception until a test // asks for the prefix, because dealing with a type initialization exception is not nice in xunit. }
static void Main () { HttpListener listener = new HttpListener (); listener.Prefixes.Add ("http://*:8081/"); listener.Start (); HttpListenerContext context = listener.GetContext (); // Create the response. HttpListenerResponse response = context.Response; string responseString = "<html><body>hi client</body></html>"; byte [] buffer = Encoding.UTF8.GetBytes (responseString); response.ContentLength64 = buffer.Length; System.Threading.Thread.Sleep (3000); response.OutputStream.Write (buffer, 0, buffer.Length); if (response != null) response.Close (); listener.Close (); string dir = AppDomain.CurrentDomain.BaseDirectory; File.Create (Path.Combine (dir, "ok")).Close (); }