public static IDisposable Create(AppFunc app, IDictionary <string, object> properties)
{
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
if (properties == null)
{
throw new ArgumentNullException(nameof(properties));
}
// Retrieve the instances created in Initialize
OwinWebListener wrapper = properties.Get <OwinWebListener>(typeof(OwinWebListener).FullName)
?? new OwinWebListener();
WebListener listener = properties.Get <WebListener>(typeof(WebListener).FullName)
?? new WebListener();
AddressList addresses = properties.Get <AddressList>(Constants.HostAddressesKey)
?? new List <IDictionary <string, object> >();
CapabilitiesDictionary capabilities =
properties.Get <CapabilitiesDictionary>(Constants.ServerCapabilitiesKey)
?? new Dictionary <string, object>();
var loggerFactory = properties.Get <LoggerFactoryFunc>(Constants.ServerLoggerFactoryKey);
wrapper.Start(listener, app, addresses, capabilities, loggerFactory);
return(wrapper);
}
public async Task HttpClient_IncludesContentLengthHeaderOnExpectedHttpVerbs(HttpMethod httpMethod)
{
BatchSharedKeyCredential creds = new BatchSharedKeyCredential(ClientUnitTestCommon.DummyAccountName, ClientUnitTestCommon.DummyAccountKey);
HttpRequestMessage message = new HttpRequestMessage(httpMethod, url);
message.Headers.Add("client-request-id", Guid.NewGuid().ToString());
await creds.ProcessHttpRequestAsync(message, CancellationToken.None);
Assert.NotNull(message.Headers.Authorization);
var settings = new WebListenerSettings()
{
Authentication = { Schemes = AuthenticationSchemes.None },
UrlPrefixes = { url }
};
using (WebListener listener = new WebListener(settings))
{
listener.Start();
Task listenTask = AcceptAndAssertAsync(httpMethod, listener, AssertRequestHasExpectedContentLength);
HttpClient client = new HttpClient();
await client.SendAsync(message);
await listenTask;
}
}
static async void ProcessRequest()
{
int count = 0;
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add("http://localhost:9000");
using (WebListener listener = new WebListener(settings))
{
listener.Start();
while (true)
{
var context = await listener.AcceptAsync();
byte[] bytes = Encoding.ASCII.GetBytes(
"ConnectionId" + context.Request.ToString() +
"\nHeaders" + context.Request.Headers
+ "\n" + DateTime.Now);
context.Response.ContentLength = bytes.Length;
context.Response.ContentType = "text/plain";
await context.Response.Body.WriteAsync(bytes, 0, bytes.Length);
context.Dispose();
Console.WriteLine("Request==>{0}", ++count);
}
}
}
public static async Task StartServerAsync(params string[] prefixes)
{
try
{
Console.WriteLine($"server starting at");
var listener = new WebListener();
foreach (var prefix in prefixes)
{
listener.Settings.UrlPrefixes.Add(prefix);
Console.WriteLine($"\t{prefix}");
}
listener.Start();
do
{
using (RequestContext context = await listener.AcceptAsync())
{
context.Response.Headers.Add("content-type", new string[] { "text/html" });
context.Response.StatusCode = (int)HttpStatusCode.OK;
byte[] buffer = GetHtmlContent(context.Request);
await context.Response.Body.WriteAsync(buffer, 0, buffer.Length);
}
} while (true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public static async Task Run(string[] args)
{
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add("http://localhost:8080");
using (WebListener listener = new WebListener(settings))
{
listener.Start();
Console.WriteLine("Running...");
while (true)
{
RequestContext context = await listener.AcceptAsync();
Console.WriteLine("Accepted");
// Context:
// context.User;
// context.DisconnectToken
// context.Dispose()
// context.Abort();
// Request
// context.Request.ProtocolVersion
// context.Request.Headers
// context.Request.Method
// context.Request.Body
// Content-Length - long?
// Content-Type - string
// IsSecureConnection
// HasEntityBody
// Response
byte[] bytes = Encoding.ASCII.GetBytes("Hello World: " + DateTime.Now);
if (context.IsWebSocketRequest)
{
Console.WriteLine("WebSocket");
WebSocket webSocket = await context.AcceptWebSocketAsync();
await webSocket.SendAsync(new ArraySegment <byte>(bytes, 0, bytes.Length), WebSocketMessageType.Text, true, CancellationToken.None);
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Goodbye", CancellationToken.None);
webSocket.Dispose();
}
else
{
Console.WriteLine("Hello World");
context.Response.ContentLength = bytes.Length;
context.Response.ContentType = "text/plain";
context.Response.Body.Write(bytes, 0, bytes.Length);
context.Dispose();
}
}
}
}
/// <summary>
/// Starts the service if it's not already running.
/// </summary>
public static void Start()
{
lock (syncLock)
{
if (listener != null)
{
return; // Already running.
}
try
{
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add($"http://localhost:{KubeHelper.ClientConfig.DesktopServicePort}/");
listener = new WebListener(settings);
listener.Start();
// Handle received requests in a background task.
Task.Run(() => RequestProcessor());
}
catch
{
listener = null;
throw;
}
}
}
private static void InitializeLocalhostWebListener(IRouter router, string webAppPath)
{
webListenerLocal = new WebListener("127.0.0.1", 80, router, webAppPath);
webListenerLocal.Start();
Console.WriteLine($"Started 127.0.0.1:80");
}
private static async Task AcceptAndAssertAsync(HttpMethod httpMethod, WebListener listener, Action <HttpMethod, RequestContext> assertLambda)
{
using RequestContext ctx = await listener.AcceptAsync();
assertLambda(httpMethod, ctx);
ctx.Response.StatusCode = 200;
}
/// <summary>
/// Captures the requests.
/// </summary>
/// <param name="count">The counter variable.</param>
/// <returns>A <see cref="Task"/> representing any asynchronous operation.</returns>
public static async Task <IList <JsonElement> > CaptureRequestsAsync(int count)
{
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add(TestWebHook);
var result = new List <JsonElement>();
using (var listener = new WebListener(settings))
{
listener.Start();
while (count-- > 0)
{
using (var requestContext = await listener.AcceptAsync().WithTimeout(TimeSpan.FromSeconds(6)).ConfigureAwait(false))
{
var body = ReadBodyStream(requestContext.Request.Body);
result.Add(body);
requestContext.Response.StatusCode = 204;
}
}
}
return(result);
}
/// <summary>
/// Creates a listener wrapper that can be configured by the user before starting.
/// </summary>
public OwinWebListener()
{
_listener = new WebListener();
_startNextRequestAsync = new Action(ProcessRequestsAsync);
_startNextRequestError = new Action <Task>(StartNextRequestError);
SetRequestProcessingLimits(DefaultMaxAccepts, DefaultMaxRequests);
}
private static async Task StartServerAsync(params string[] prefixes)
{
try
{
WriteLine("server starting at");
var listener = new WebListener(new WebListenerSettings {
RequestQueueLimit = 10
});
foreach (var prefix in prefixes)
{
listener.Settings.UrlPrefixes.Add(prefix);
WriteLine($"\t{prefix}");
}
listener.Start();
do
{
using (var context = await listener.AcceptAsync().ConfigureAwait(false))
{
context.Response.Headers.Add("content-type", new[] { "text/html" });
context.Response.StatusCode = (int)HttpStatusCode.OK;
var buffer = GetHtmlContent(context.Request);
await context.Response.Body.WriteAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
}
} while (true);
}
catch (Exception ex)
{
WriteLine(ex.Message);
}
}
private void StartHttpListener()
{
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add(Configuration.RedirectUrl);
WebListener = new WebListener(settings);
WebListener.Start();
}
public HttpReceiver(string httpAddress, int port)
{
_port = port;
_address = httpAddress;
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add($"{_address}:{_port}");
_webListener = new WebListener(settings);
}
/// <summary>
/// Initializes the Httplistener to listen to a particular port of localhost
/// </summary>
/// <param name="port"></param>
public MockWebServer(int port)
{
_threadWorker = new Thread(Run);
_list = new Queue <MockResponse>();
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add("http://" + Host + ":" + port + "/");
_webListener = new WebListener(settings);
}
public void Start()
{
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add((string)urlPrefix);
stopTokenSource = new CancellationTokenSource();
listener = new WebListener(settings);
listener.Start();
workerTask = Task.Run(Listen);
client = new HttpClient();
}
/// <inheritdoc/>
public void Dispose()
{
lock (syncLock)
{
if (listener != null)
{
listener.Dispose();
listener = null;
}
}
}
private async static Task SignInAsync()
{
// create a redirect URI using an available port on the loopback address.
string redirectUri = string.Format("http://127.0.0.1:7890/");
// create an HttpListener to listen for requests on that redirect URI.
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add(redirectUri);
var http = new WebListener(settings);
http.Start();
Console.WriteLine("Listening..");
var options = new OidcClientOptions
{
Authority = _authority,
ClientId = "native.hybrid",
RedirectUri = redirectUri,
Scope = "openid profile api",
FilterClaims = true,
LoadProfile = true,
Flow = OidcClientOptions.AuthenticationFlow.Hybrid
};
var serilog = new LoggerConfiguration()
.MinimumLevel.Verbose()
.Enrich.FromLogContext()
.WriteTo.LiterateConsole(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message}{NewLine}{Exception}{NewLine}")
.CreateLogger();
options.LoggerFactory.AddSerilog(serilog);
var client = new OidcClient(options);
var state = await client.PrepareLoginAsync();
OpenBrowser(state.StartUrl);
var context = await http.AcceptAsync();
var formData = GetRequestPostData(context.Request);
if (formData == null)
{
Console.WriteLine("Invalid response");
return;
}
await SendResponseAsync(context.Response);
var result = await client.ProcessResponseAsync(formData, state);
ShowResult(result);
}
/// <summary>
/// Starts the listener and request processing threads.
/// </summary>
public void Start(WebListener listener, AppFunc appFunc, IList <IDictionary <string, object> > addresses,
IDictionary <string, object> capabilities, LoggerFactoryFunc loggerFactory)
{
Contract.Assert(_appFunc == null); // Start should only be called once
Contract.Assert(appFunc != null);
Contract.Assert(addresses != null);
_listener = listener;
_appFunc = appFunc;
_logger = LogHelper.CreateLogger(loggerFactory, typeof(OwinWebListener));
_basePaths = new List <string>();
foreach (var address in addresses)
{
// build url from parts
string scheme = address.Get <string>("scheme") ?? Uri.UriSchemeHttp;
string host = address.Get <string>("host") ?? "localhost";
string port = address.Get <string>("port") ?? "5000";
string path = address.Get <string>("path") ?? string.Empty;
// if port is present, add delimiter to value before concatenation
if (!string.IsNullOrWhiteSpace(port))
{
port = ":" + port;
}
// Assume http(s)://+:9090/BasePath/, including the first path slash. May be empty. Must end with a slash.
if (!path.EndsWith("/", StringComparison.Ordinal))
{
// Http.Sys requires that the URL end in a slash
path += "/";
}
_basePaths.Add(path);
// add a server for each url
string url = scheme + "://" + host + port + path;
_listener.Settings.UrlPrefixes.Add(url);
}
_capabilities = capabilities;
if (!_listener.IsListening)
{
_listener.Start();
}
SetRequestQueueLimit();
_disconnectHandler = new DisconnectHandler(_listener, _logger);
OffloadStartNextRequest();
}
private static void InitializeLocalWebListeners(IRouter router, string webAppPath, string localIP)
{
try
{
var webListener = new WebListener(localIP.ToString(), 80, router, webAppPath);
webListener.Start();
Console.WriteLine($"Started {localIP.ToString()}:80");
}
catch (Exception ex)
{
Console.WriteLine($"{ex.Message}\r\nFailed to start {localIP.ToString()}:80\r\nLaunch \"as administrator?\"");
}
}
public async Task SignInAsync(AuthenticationOptions authOptions)
{
// create a redirect URI using an available port on the loopback address.
var redirectUri = "http://127.0.0.1:7890/";
// create an HttpListener to listen for requests on that redirect URI.
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add(redirectUri);
using (var http = new WebListener(settings))
{
http.Start();
var options = new OidcClientOptions
{
Authority = authOptions.Url,
ClientId = authOptions.ClientId,
ClientSecret = authOptions.ClientSecret,
RedirectUri = redirectUri,
Scope = "openid profile auth_api.Internal",
FilterClaims = true,
LoadProfile = true,
Flow = OidcClientOptions.AuthenticationFlow.Hybrid
};
var client = new OidcClient(options);
var state = await client.PrepareLoginAsync();
OpenBrowser(state.StartUrl);
var context = await http.AcceptAsync();
var formData = GetRequestPostData(context.Request);
if (formData == null)
{
throw new AuthenticationException("Invalid response");
}
await SendResponseAsync(context.Response);
var result = await client.ProcessResponseAsync(formData, state);
if (result.IsError)
{
throw new AuthenticationException(result.Error);
}
m_authTokenProvider.AuthToken = result.AccessToken;
}
}
private static async Task <string> Authorize()
{
var patreonApi = new PatreonApi(clientId, clientSecret, redirectURI);
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add("http://localhost:3000");
var uri =
patreonApi.BuildAuthorizeEndpoint(new List <string>( )
{
"identity", "identity.memberships", "campaigns", "campaigns.members"
});
string queryString = string.Empty;
using (WebListener listener = new WebListener(settings))
{
listener.Start();
// Opens request in the browser.
OpenBrowser(uri.ToString());
using (var context = await listener.AcceptAsync())
{
byte[] bytes = Encoding.ASCII.GetBytes("<html><head><meta http-equiv=\'refresh\'></head><body>Success</body></html>");
context.Response.ContentLength = bytes.Length;
context.Response.ContentType = "text/html";
await context.Response.Body.WriteAsync(bytes, 0, bytes.Length);
queryString = context.Request.QueryString;
}
}
var queryDictionary = HttpUtility.ParseQueryString(queryString);
// Checks for errors.
if (queryDictionary.GetValues("error")?.FirstOrDefault() != null)
{
return(string.Empty);
}
if (queryDictionary.GetValues("code")?.FirstOrDefault() == null)
{
return(string.Empty);
}
// extracts the code
return(queryDictionary.GetValues("code").FirstOrDefault());
}
private async static Task SignInAsync()
{
// create a redirect URI using an available port on the loopback address.
string redirectUri = string.Format("http://127.0.0.1:45656");
// create an HttpListener to listen for requests on that redirect URI.
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add(redirectUri);
var http = new WebListener(settings);
http.Start();
Console.WriteLine("Listening..");
var options = new OidcClientOptions
{
Authority = _authority,
ClientId = "oidcMVCApp",
ClientSecret = "ProCodeGuide",
RedirectUri = redirectUri,
Scope = "weatherApi.read openid profile",
FilterClaims = true,
LoadProfile = true,
};
var client = new OidcClient(options);
var state = await client.PrepareLoginAsync();
Console.WriteLine($"State: {System.Text.Json.JsonSerializer.Serialize(state)}");
OpenBrowser(state.StartUrl);
var context = await http.AcceptAsync();
var formData = GetRequestPostData(context.Request);
if (formData == null)
{
Console.WriteLine("Invalid response");
return;
}
await SendResponseAsync(context.Response);
var result = await client.ProcessResponseAsync(context.Request.RawUrl, state);
ShowResult(result);
}
private void ListenThread(object obj)
{
var settings = new WebListenerSettings();
var urlPrefix = $"http://{this.host}:{this.port}/";
// File.WriteAllText("C:\\Temp\\UrlPrefixes.txt", urlPrefix);
settings.UrlPrefixes.Add(urlPrefix);
this.listener = new WebListener(settings);
this.listener.Start();
while (this.threadRunning)
{
var task = listener.AcceptAsync();
task.ContinueWith(o =>
{
if (o.IsFaulted)
{
return;
}
var context = o.Result;
if (context.Request.Method == "GET")
{
HandleGetRequest(context);
}
if (context.Request.Method == "POST")
{
HandlePostRequest(context);
}
if (context.Request.Method == "PUT")
{
HandlePutRequest(context);
}
if (context.Request.Method == "OPTIONS")
{
HandleOptionsRequest(context);
}
if (context.Request.Method == "DELETE")
{
HandleDeleteRequest(context);
}
}).Wait();
}
}
/// <summary>
///Getter method for Webdriver in which instance the testcase need to run whether on linear mode/null or remote mode(Grid and Saucelabs) Use this whenever want to use/pass webdriver
/// </summary>
/// <params>None</params>
/// <return>Webdriver Instance</returns>
public IWebDriver GetDriver()
{
if (_autoutilities.GetKeyValue("MODEOFEXECUTION", "ExecutionMode").ToLower() == "linear" || _autoutilities.GetKeyValue("MODEOFEXECUTION", "ExecutionMode") == "" || _autoutilities.GetKeyValue("MODEOFEXECUTION", "ExecutionMode").ToLower() == null)
{
Driver = InitialSetupWebdriver();
}
else if (_autoutilities.GetKeyValue("MODEOFEXECUTION", "ExecutionMode").ToLower() == "remote")
{
//Driver = new RemoteBrowser().InitialiseRemoteDriver();
}
WebListener webListener = new WebListener(Driver);
Driver = webListener.Driver;
return(Driver);
}
private async static Task SignInAsync()
{
string redirectUri = string.Format("http://127.0.0.1:7890/");
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add(redirectUri);
var http = new WebListener(settings);
http.Start();
var options = new OidcClientOptions
{
Authority = _authority,
ClientId = "demo-app",
RedirectUri = redirectUri,
Scope = "openid",
FilterClaims = true,
LoadProfile = true,
Flow = OidcClientOptions.AuthenticationFlow.AuthorizationCode,
Policy = new Policy()
{
RequireAccessTokenHash = false
}
};
var client = new OidcClient(options);
var state = await client.PrepareLoginAsync();
OpenBrowser(state.StartUrl);
var context = await http.AcceptAsync();
var formData = GetRequestPostData(context.Request);
if (formData == null)
{
Console.WriteLine("Invalid response");
return;
}
await SendResponseAsync(context.Response);
var result = await client.ProcessResponseAsync(formData, state);
ShowResult(result);
}
private static async Task SignInAsync()
{
// create an HttpListener to listen for requests on that redirect URI.
string redirectUri = string.Format("http://127.0.0.1:7890");
WebListenerSettings settings = new WebListenerSettings();
settings.UrlPrefixes.Add(redirectUri);
WebListener http = new WebListener(settings);
http.Start();
Console.WriteLine("Listening..");
OidcClientOptions options = new OidcClientOptions
{
Authority = "https://localhost:62189/identity",
RedirectUri = redirectUri,
ClientId = "console",
ClientSecret = "peng",
Scope = "openid offline_access",
Flow = OidcClientOptions.AuthenticationFlow.Hybrid
};
OidcClient client = new OidcClient(options);
AuthorizeState state = await client.PrepareLoginAsync();
OpenBrowser(state.StartUrl);
RequestContext context = await http.AcceptAsync();
string formData = GetRequestPostData(context.Request);
if (formData == null)
{
Console.WriteLine("Invalid response");
return;
}
await SendResponseAsync(context.Response);
LoginResult result = await client.ProcessResponseAsync(formData, state);
ShowResult(result);
}
public static async Task Run(string[] args)
{
var settings = new WebListenerSettings();
settings.UrlPrefixes.Add($"http://{args[1]}:80");
using (WebListener listener = new WebListener(settings))
{
using (var sem = new Semaphore(0, 1, $"{args[1]}"))
{
sem.Release();
listener.Start();
}
Console.WriteLine("{0} started", DateTime.UtcNow.ToString("o"));
while (true)
{
RequestContext context = await listener.AcceptAsync();
Console.WriteLine("{0} accepted", DateTime.UtcNow.ToString("o"));
// Response
var html = Path.Combine(_path, "index.html");
var bytes = File.ReadAllBytes(html);
if (context.Request.Path != "/")
{
StringBuilder strb = new StringBuilder();
foreach (ProcessModule module in Process.GetCurrentProcess().Modules)
{
strb.AppendLine(module.FileName);
}
bytes = Encoding.UTF8.GetBytes(strb.ToString());
}
//Console.WriteLine("Hello World");
context.Response.ContentLength = bytes.Length;
context.Response.ContentType = "text/plain";
context.Response.Body.Write(bytes, 0, bytes.Length);
context.Dispose();
}
}
}
/// <summary>
/// Stops the service if it's not already stopped.
/// </summary>
public static void Stop()
{
lock (syncLock)
{
if (listener == null)
{
return; // Already stopped.
}
try
{
listener.Dispose();
}
finally
{
listener = null;
}
}
}
private async Task listenLoop(WebListener listener, CancellationToken tok)
{
_logInfo($"Listening loop started.");
while (true)
{
try
{
if (!listener.IsListening || tok.IsCancellationRequested)
{
break;
}
var requestContext = await listener.AcceptAsync().ConfigureAwait(false);
Func <WebListenerWebSocketServerBehavior> builder = null;
if (!_behaviors.TryGetValue(requestContext.Request.RawUrl, out builder))
{
_logError($"There is no behavior defined for {requestContext.Request.RawUrl}");
requestContext.Response.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
requestContext.Abort();
}
else
{
Task.Run(async() => await handleClient(requestContext, builder, tok));
}
}
catch (HttpListenerException listenerex)
{
_logInfo($"HttpListenerException {listenerex}");
}
catch (OperationCanceledException canceledex)
{
_logInfo($"OperationCanceledException {canceledex}");
}
catch (Exception e)
{
_logError(e.ToString());
}
}
_logInfo($"Listening loop stopped.");
}
internal DisconnectHandler(WebListener listener, LoggerFunc logger)
{
_connectionCancellationTokens = new ConcurrentDictionary <ulong, ConnectionCancellation>();
_listener = listener;
_logger = logger;
// Get the request queue handle so we can register for disconnect
FieldInfo requestQueueHandleField = typeof(WebListener).GetField("m_RequestQueueHandle", BindingFlags.Instance | BindingFlags.NonPublic);
// Get the connection id field info from the request object
_connectionIdField = typeof(Request).GetField("m_ConnectionId", BindingFlags.Instance | BindingFlags.NonPublic);
if (requestQueueHandleField != null && requestQueueHandleField.FieldType == typeof(CriticalHandle))
{
_requestQueueHandle = (CriticalHandle)requestQueueHandleField.GetValue(_listener);
}
if (_connectionIdField == null || _requestQueueHandle == null)
{
LogHelper.LogInfo(_logger, "Unable to resolve handles. Disconnect notifications will be ignored.");
}
}
public static async Task StartServerAsync(params string[] prefixes)
{
try
{
WriteLine($"server starting at");
var listener = new WebListener();
foreach (var prefix in prefixes)
{
listener.UrlPrefixes.Add(prefix);
WriteLine($"\t{prefix}");
}
listener.Start();
do
{
using (RequestContext context = await listener.GetContextAsync())
{
context.Response.Headers.Add("content-type", new string[] { "text/html" });
context.Response.StatusCode = (int)HttpStatusCode.OK;
byte[] buffer = GetHtmlContent(context.Request);
await context.Response.Body.WriteAsync(buffer, 0, buffer.Length);
}
} while (true);
}
catch (Exception ex)
{
WriteLine(ex.Message);
}
}
