// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) { loggerFactory.AddConsole(Configuration.GetSection("Logging")); loggerFactory.AddDebug(); app.UseOwin(pipeline => pipeline(next => context => { foreach (string key in context.Keys) { Console.WriteLine($"{key}: {context[key]}"); } return(next(context)); })); // alternative app.Use((context, next) => { OwinEnvironment environment = new OwinEnvironment(context); IDictionary <string, string[]> headers = (IDictionary <string, string[]>)environment.Single(item => item.Key == "owin.RequestHeaders").Value; return(next()); }); app.Use((context, next) => { OwinEnvironment environment = new OwinEnvironment(context); OwinFeatureCollection features = new OwinFeatureCollection(environment); IDictionary <string, string[]> headers = (IDictionary <string, string[]>)features.Environment["owin.RequestHeaders"]; return(next()); }); app.UseMvc(); }
protected IDictionary <string, object> SessionState(OwinFeatureCollection context) { if (context.Environment.ContainsKey("its.SessionState")) { return(context.Environment["its.SessionState"] as IDictionary <string, object>); } return(null); }
protected T GetSessionStateObject <T>(OwinFeatureCollection context, string key) { var session = SessionState(context); if (session.ContainsKey(key)) { return((T)session[key]); } return(default(T)); }
protected void SetSessionStateObject <T>(OwinFeatureCollection context, string key, T val) { var session = SessionState(context); if (session.ContainsKey(key)) { session.Remove(key); } session[key] = val; }
private JrpcContext ConvertToContext(IDictionary <string, object> environment) { OwinFeatureCollection collection = new OwinFeatureCollection(environment); var context = new JrpcContext { JrpcRequestContext = new KestrelJrpcRequestContext(collection, collection), JrpcResponseContext = new KestrelJrpcResponseContext(collection) }; return(context); }
public Task Invoke(HttpContext context) { var owinEnvironment = new OwinEnvironment(context); var owinFeatures = new OwinFeatureCollection(owinEnvironment); var requestId = owinFeatures.Environment.ContainsKey("owin.RequestId") ? owinFeatures.Environment["owin.RequestId"] : string.Empty; var requestMethod = owinFeatures.Environment.ContainsKey("owin.RequestMethod") ? owinFeatures.Environment["owin.RequestMethod"] : string.Empty; var requestPath = owinFeatures.Environment.ContainsKey("owin.RequestPath") ? owinFeatures.Environment["owin.RequestPath"] : string.Empty; this.logger.LogInformation("[RequestId: {0}][RequestMethod: {1}][RequestPath: {2}]", requestId, requestMethod, requestPath); return(this.next(context)); }
public Task StartAsync <TContext>(IHttpApplication <TContext> application, CancellationToken cancellationToken) { return(Task.Run(() => { Func <IDictionary <string, object>, Task> appFunc = async env => { var owinFeatures = new OwinFeatureCollection(env); var features = new FeatureCollection(owinFeatures); var owinHttpResponse = features.Get <IHttpResponseFeature>(); features.Set <IHttpResponseFeature>(new NoOnStartingHttpResponseFeature(owinHttpResponse)); var context = application.CreateContext(features); try { await application.ProcessRequestAsync(context); } catch (Exception ex) { application.DisposeContext(context, ex); throw; } application.DisposeContext(context, null); }; // Convert OWIN WebSockets to ASP.NET Core WebSockets appFunc = OwinWebSocketAcceptAdapter.AdaptWebSockets(appFunc); // Wrap this into a middleware handler that Fos can accept Func <IDictionary <string, object>, Func <IDictionary <string, object>, Task>, Task> middlewareHandler = async(env, next) => { await appFunc(env); if (next != null) { await next(env); } }; cgiServer = new FosSelfHost(builder => { builder.Use(middlewareHandler); }); cgiServer.Bind(IPAddress.Loopback, 9000); cgiServer.Start(true); }, cancellationToken)); }
public void OwinHttpEnvironmentCanBeCreated() { var env = new Dictionary <string, object> { { "owin.RequestMethod", HttpMethods.Post }, { "owin.RequestPath", "/path" }, { "owin.RequestPathBase", "/pathBase" }, { "owin.RequestQueryString", "name=value" }, }; var features = new OwinFeatureCollection(env); var requestFeature = Get <IHttpRequestFeature>(features); Assert.Equal(requestFeature.Method, HttpMethods.Post); Assert.Equal("/path", requestFeature.Path); Assert.Equal("/pathBase", requestFeature.PathBase); Assert.Equal("?name=value", requestFeature.QueryString); }
internal RequestDelegate Middleware(RequestDelegate nextMiddleware) { RequestDelegate appFunc = async(HttpContext context) => { var environment = new OwinEnvironment(context); var features = new OwinFeatureCollection(environment); if (!features.Environment.ContainsKey("its.SessionState")) { var state = new Dictionary <string, object>( ); features.Environment["its.SessionState"] = state; } await this.InvokeAt(context, 0); }; return(appFunc); }
public Task StartAsync <TContext>(IHttpApplication <TContext> application, CancellationToken cancellationToken) { // Note that this example does not take into account of Nowin's "server.OnSendingHeaders" callback. // Ideally we should ensure this method is fired before disposing the context. Invoke = async env => { // try without wrapping aspnet trys to add so it doesn't work // var features = new OwinFeatureCollection(env); // The reason for 2 level of wrapping is because the OwinFeatureCollection isn't mutable // so features can't be added var owinFeatures = new OwinFeatureCollection(env); // enumerating the env owin.ResponseHeaders causes Content-Type to default to text/html which messes up content negotiation // set it to empty so AspNetCore can decide the final Content-Type owinFeatures.Get <IHttpResponseFeature>().Headers["Content-Type"] = ""; var features = new FeatureCollection(owinFeatures); var context = application.CreateContext(features); try { await application.ProcessRequestAsync(context); } catch (Exception ex) { application.DisposeContext(context, ex); throw; } application.DisposeContext(context, null); }; // Add the web socket adapter so we can turn OWIN websockets into ASP.NET Core compatible web sockets. // The calling pattern is a bit different // Invoke = OwinWebSocketAcceptAdapter.AdaptWebSockets(Invoke); return(Task.CompletedTask); }
public void OwinHttpEnvironmentCanBeModified() { var env = new Dictionary <string, object> { { "owin.RequestMethod", HttpMethods.Post }, { "owin.RequestPath", "/path" }, { "owin.RequestPathBase", "/pathBase" }, { "owin.RequestQueryString", "name=value" }, }; var features = new OwinFeatureCollection(env); var requestFeature = Get <IHttpRequestFeature>(features); requestFeature.Method = HttpMethods.Get; requestFeature.Path = "/path2"; requestFeature.PathBase = "/pathBase2"; requestFeature.QueryString = "?name=value2"; Assert.Equal(HttpMethods.Get, Get <string>(env, "owin.RequestMethod")); Assert.Equal("/path2", Get <string>(env, "owin.RequestPath")); Assert.Equal("/pathBase2", Get <string>(env, "owin.RequestPathBase")); Assert.Equal("name=value2", Get <string>(env, "owin.RequestQueryString")); }