/// <summary> /// Initializes a new instance of the <see cref="NancySentryRequest"/> class. /// </summary> /// <param name="httpContext">The HTTP context.</param> internal NancySentryRequest(NancyContext httpContext) { this.httpContext = httpContext; if (!HasHttpContext || this.httpContext.Request == null) return; // Url and Method Url = this.httpContext.Request.Url.ToString(); Method = this.httpContext.Request.Method; Data = this.httpContext.Request.Form; // QueryString string qs = string.Empty; foreach (var item in this.httpContext.Request.Query) qs += item + "=" + this.httpContext.Request.Query[item] + "&"; QueryString = qs.TrimEnd(new[] { '&' }); // Cookies Cookies = this.httpContext.Request.Cookies; // Headers Headers = this.httpContext.Request.Headers.Select(s => new { Key = s.Key, Value = s.Value.Aggregate(new StringBuilder(), (stringBuilder, argument) => { stringBuilder.Append(argument); stringBuilder.Append(" "); return stringBuilder; }).ToString().TrimEnd(new[] { ' ' }) }).ToDictionary(k => k.Key, v => v.Value); }
public override Response ProcessRequest(NancyContext context) { if (!context.Request.Url.Path.StartsWith(HandlerRoot, StringComparison.InvariantCultureIgnoreCase)) { return null; } var path = context.Request.Url.Path.Remove(0, HandlerRoot.Length + 1); var match = Regex.Match(path, @"^(?<filename>.*)_[a-z0-9]+_(?<extension>[a-z]+)$", RegexOptions.IgnoreCase); if (match.Success == false) { if (Logger != null) Logger.Error("RawFileRouteHandler.ProcessRequest : Invalid file path in URL '{0}'", path); return null; } var extension = match.Groups["extension"].Value; var filePath = Path.Combine(applicationRoot, string.Concat(match.Groups["filename"].Value, ".", extension).Replace('/', '\\')); if (!File.Exists(filePath)) { if (Logger != null) Logger.Error("RawFileRouteHandler.ProcessRequest : Raw file does not exist '{0}'", filePath); return null; } var response = new StreamResponse(() => File.OpenRead(filePath), MimeTypes.GetMimeType(filePath)); if (Logger != null) Logger.Trace("RawFileRouteHandler.ProcessRequest : Returned response for '{0}'", context.Request.Url.Path); return response; }
public void Handle_WhenTestContextIsSetOnTheRepository_DoesNotLogTheTextContext() { const string testContext = "EventsApiConsumerTests.GetAllEvents_WhenCalled_ReturnsAllEvents"; var headers = new Dictionary<string, IEnumerable<string>> { { Constants.AdministrativeRequestTestContextHeaderKey, new List<string> { testContext } } }; var context = new NancyContext { Request = new Request("DELETE", new Url { Path = "/interactions", Scheme = "http" }, null, headers) }; var handler = GetSubject(); _mockProviderRepository.TestContext.Returns(testContext); handler.Handle(context); _mockLog.Received(0).Log(LogLevel.Info, Arg.Any<Func<string>>(), null, Arg.Is<object[]>(x => x.Single() == testContext)); }
private void CompressResponse(NancyContext context) { var request = context.Request; var response = context.Response; try { if ( !response.ContentType.Contains("image") && !response.ContentType.Contains("font") && request.Headers.AcceptEncoding.Any(x => x.Contains("gzip")) && !AlreadyGzipEncoded(response) && !ContentLengthIsTooSmall(response)) { var contents = response.Contents; response.Headers["Content-Encoding"] = "gzip"; response.Contents = responseStream => { using (var gzip = new GZipStream(responseStream, CompressionMode.Compress, true)) using (var buffered = new BufferedStream(gzip, 8192)) { contents.Invoke(buffered); } }; } } catch (Exception ex) { _logger.Error(ex, "Unable to gzip response"); throw; } }
/// <summary> /// Perform any initialisation tasks /// </summary> /// <param name="pipelines">Application pipelines</param> /// <param name="context">The current context</param> public void Initialize(IPipelines pipelines, NancyContext context) { // On each request, store the NancyContext in the LogicalCallContext CallContext.LogicalSetData(NancyConfiguration.NancyContextDataSlot, context); var nancyConfiguration = NancyConfiguration.Settings; if (nancyConfiguration == null) return; var name = nancyConfiguration.PipelineName.Value; var sharpRaven = new PipelineItem(name, (nancyContext, exception) => { if (nancyConfiguration.CaptureExceptionOnError.Value) { var guid = this.ravenClient.CaptureException(exception); if (guid != null) { context.Items.Add(NancyConfiguration.SentryEventGuidKey, guid); exception.Data.Add(NancyConfiguration.SentryEventGuidKey, guid); } } return null; }); pipelines.OnError.AddItemToStartOfPipeline(sharpRaven); }
public void Handle(Nancy.HttpStatusCode statusCode, Nancy.NancyContext context) { if (context.Request.Headers.Accept.Count() == 0) { return; } if (context.Request.Headers.Accept.First().Item1.Contains("/json") || context.Request.Headers.Accept.First().Item1.Contains("/xml")) { return; } // this is most probably XmlHttpRequest if (context.Request.Method == "PATCH" || context.Request.Method == "DELETE") { return; } if (context.Request.Method == "GET" || context.Request.Method == "POST" || context.Request.Headers.UserAgent.Contains("Mozilla") || context.Request.Headers.UserAgent.Contains("WebKit") || context.Request.Headers.UserAgent.Contains("Trident")) { var response = _renderer.RenderView(context, "Codes/" + (int)statusCode); response.StatusCode = statusCode; response.ContentType = "text/html; charset=utf-8"; context.Response = response; } }
/// <summary> /// Transmogrify original response and apply JSONP Padding /// </summary> /// <param name="context">Current Nancy Context</param> private static void PrepareJsonp(NancyContext context) { var isJson = Json.Json.IsJsonContentType(context.Response.ContentType); bool hasCallback = context.Request.Query["callback"].HasValue; if (!isJson || !hasCallback) { return; } // grab original contents for running later var original = context.Response.Contents; string callback = context.Request.Query["callback"].Value; // set content type to application/javascript so browsers can handle it by default // http://stackoverflow.com/questions/111302/best-content-type-to-serve-jsonp context.Response.ContentType = string.Concat("application/javascript", Encoding); context.Response.Contents = stream => { // disposing of stream is handled elsewhere var writer = new StreamWriter(stream) { AutoFlush = true }; writer.Write("{0}(", callback); original(stream); writer.Write(");"); }; }
public IUserIdentity GetUserFromIdentifier(Guid identifier, NancyContext context) { if (!cachedUsers.ContainsKey(identifier)) return null; User info = cachedUsers[identifier]; return new UserIndentity {UserName = info.Login, Claims = new List<string> {info.Role.ToString()}, AuthId = identifier}; }
static object DeleteMember( NancyContext context, IDocumentSession documentSession, string alias) { if (context == null) throw new ArgumentNullException("context"); if (documentSession == null) throw new ArgumentNullException("documentSession"); if (String.IsNullOrEmpty(alias)) return 404; if (!context.IsSignedUp()) return 403; var memberToDelete = documentSession.GetMemberByAlias(alias); if (memberToDelete == null) return 404; var currentMember = context.GetCurrentMember(documentSession); Debug.Assert(currentMember != null, "`requireSignedUp()` should ensure the current member is not null."); if (!memberToDelete.Alias.Equals(currentMember.Alias, StringComparison.OrdinalIgnoreCase)) return 403; documentSession.DeleteMember(memberToDelete.Id); context.SetAlert("Your membership was deleted.", type: AlertType.Success); context.SignOutOfTwitter(); return context.Redirect(Paths.Home()); }
public bool IsCacheable(NancyContext context) { if (!RuntimeInfoBase.IsProduction) { return false; } if (((DynamicDictionary)context.Request.Query).ContainsKey("h")) return true; if (context.Request.Path.StartsWith("/api", StringComparison.CurrentCultureIgnoreCase)) { if (context.Request.Path.ContainsIgnoreCase("/MediaCover")) return true; return false; } if (context.Request.Path.StartsWith("/signalr", StringComparison.CurrentCultureIgnoreCase)) return false; if (context.Request.Path.EndsWith("main.js")) return false; if (context.Request.Path.StartsWith("/feed", StringComparison.CurrentCultureIgnoreCase)) return false; if (context.Request.Path.StartsWith("/log", StringComparison.CurrentCultureIgnoreCase) && context.Request.Path.EndsWith(".txt", StringComparison.CurrentCultureIgnoreCase)) { return false; } if (context.Response != null) { if (context.Response.ContentType.Contains("text/html")) return false; } return true; }
protected override void RequestStartup(TinyIoCContainer requestContainer, IPipelines pipelines, NancyContext context) { base.RequestStartup(requestContainer, pipelines, context); // At request startup we modify the request pipelines to // include forms authentication - passing in our now request // scoped user name mapper. // // The pipelines passed in here are specific to this request, // so we can add/remove/update items in them as we please. var loginService = requestContainer.Resolve<LoginService>(); var authConfiguration = new StatelessAuthenticationConfiguration(c => { var apiKeyFromRequest = ((DynamicDictionaryValue)c.Request.Query.ApiKey).Value as ApiKey ?? ((DynamicDictionaryValue)c.Request.Form.ApiKey).Value as ApiKey; if (apiKeyFromRequest == null) return null; if (loginService.IsApiKeyValid(apiKeyFromRequest)) { return new UserIdentity(apiKeyFromRequest.Username, new List<string>()); } return null; }); StatelessAuthentication.Enable(pipelines, authConfiguration); }
protected override void RequestStartup(TinyIoCContainer container, IPipelines pipelines, NancyContext context) { var formsAuthConfig = new FormsAuthenticationConfiguration { RedirectUrl = "~/login", UserMapper = container.Resolve<IUserMapper>() }; FormsAuthentication.Enable(pipelines, formsAuthConfig); pipelines.AfterRequest += ctx => { var dbContext = container.Resolve<SmartFlowContext>(); dbContext.SaveChanges(); }; pipelines.OnError += (ctx, ex) => { var logger = container.Resolve<TextFileLogger>(); logger.Write("Error", Enums.LogLevel.ApplicationError, ex); return ErrorResponse.FromException(ex); }; base.RequestStartup(container, pipelines, context); }
public static RequestInfo Collect(NancyContext context, ExceptionlessClient client) { if (context == null) return null; var info = new RequestInfo { ClientIpAddress = context.Request.UserHostAddress, HttpMethod = context.Request.Method }; if (context.Request.Headers.UserAgent != null) info.UserAgent = context.Request.Headers.UserAgent; if (context.Request.Url != null) { info.Host = context.Request.Url.HostName; info.IsSecure = context.Request.Url.IsSecure; info.Path = context.Request.Url.BasePath + context.Request.Url.Path; info.Port = context.Request.Url.Port ?? 80; } if (context.Request.Headers.Referrer != null) info.Referrer = context.Request.Headers.Referrer; info.Cookies = context.Request.Cookies.ToDictionary(client); if (context.Request.Url != null && !String.IsNullOrWhiteSpace(context.Request.Url.Query)) info.QueryString = HttpUtility.ParseQueryString(context.Request.Url.Query).ToDictionary(client); return info; }
// The bootstrapper enables you to reconfigure the composition of the framework, // by overriding the various methods and properties. // For more information https://github.com/NancyFx/Nancy/wiki/Bootstrapper //protected override void ApplicationStartup(ILifetimeScope container, IPipelines pipelines) //{ // // No registrations should be performed in here, however you may // // resolve things that are needed during application startup. //} //protected override void ConfigureApplicationContainer(ILifetimeScope existingContainer) //{ // // Perform registration that should have an application lifetime //} protected override void ConfigureRequestContainer(ILifetimeScope container, NancyContext context) { // Perform registrations that should have a request lifetime var builder = new ContainerBuilder(); builder.RegisterModule(new ServicesModule()); builder.Update(container.ComponentRegistry); }
public Response RunCassetteRequestHandler(NancyContext context) { try { logger.Info("RunCassetteRequestHandler : {0}", context.Request.Path); if (!context.Request.Path.StartsWith(string.Concat("/", UrlModifier.CassettePrefix))) return null; var requestPath = context.Request.Path.Substring(UrlModifier.CassettePrefix.Length); if (String.IsNullOrWhiteSpace(requestPath) || requestPath == "/") { var diagnosticsHandler = Container.Resolve<ICassetteRequestHandler>(DiagnosticRequestHandler.PathPrefix); return diagnosticsHandler.ProcessRequest(context, requestPath); } return CallPathHandler(context, requestPath); } catch (Exception ex) { logger.FatalException(string.Format("RunCassetteRequestHandler : {0} : {1}", ex.GetType(), ex.Message), ex); return null; } }
public void Handle_WhenExpectedResponseHasNotBeenSet_ResponseMapperIsCalledAndReturns500Response() { var nancyContext = new NancyContext { Request = new Request("GET", "/", "HTTP") }; var interactions = new List<ProviderServiceInteraction> { new ProviderServiceInteraction { Request = new ProviderServiceRequest(), Response = null } }; nancyContext.SetMockInteraction(interactions); var mockRequestMapper = Substitute.For<IProviderServiceRequestMapper>(); var mockResponseMapper = Substitute.For<INancyResponseMapper>(); var mockProviderRepository = Substitute.For<IMockProviderRepository>(); mockResponseMapper.Convert(Arg.Any<ProviderServiceResponse>()) .Returns(new Response { StatusCode = HttpStatusCode.InternalServerError }); IMockProviderRequestHandler handler = new MockProviderRequestHandler(mockRequestMapper, mockResponseMapper, mockProviderRepository); var result = handler.Handle(nancyContext); mockResponseMapper.Received(1).Convert(Arg.Is<ProviderServiceResponse>(x => x.Status == 500)); Assert.Equal(HttpStatusCode.InternalServerError, result.StatusCode); }
private NancyModule GetInitializedModuleForMatch(NancyContext context, RouteCandidate routeMatchToReturn) { var module = this.nancyModuleCatalog.GetModuleByKey(routeMatchToReturn.Item1, context); return(this.moduleBuilder.BuildModule(module, context)); }
protected override void RequestStartup(IWindsorContainer container, IPipelines pipelines, NancyContext context) { //var formsAuthConfiguration = new FormsAuthenticationConfiguration //{ // RedirectUrl = "/login", // UserMapper = container.Resolve<IUserMapper>(), //}; //FormsAuthentication.Enable(pipelines, formsAuthConfiguration); pipelines.BeforeRequest.AddItemToEndOfPipeline(ctx => { if (ctx.CurrentUser != null) ctx.ViewBag.UserName = ctx.CurrentUser.UserName; return null; }); pipelines.BeforeRequest.AddItemToStartOfPipeline(nancyContext => { //nancyContext.Request.Headers.UserAgent = "Lightstone"; var token = ""; var cookie = nancyContext.Request.Headers.Cookie.FirstOrDefault(x => (x.Name + "").ToLower() == "token"); if (cookie != null) token = HttpUtility.UrlDecode(cookie.Value); //nancyContext.Request.Headers.Authorization = "Token {0}".FormatWith(HttpUtility.UrlDecode(token.Value)); var user = container.Resolve<ITokenizer>().Detokenize(token, nancyContext, new DefaultUserIdentityResolver()); if (user != null) nancyContext.CurrentUser = user; return null; }); TokenAuthentication.Enable(pipelines, new TokenAuthenticationConfiguration(container.Resolve<ITokenizer>())); }
private static Response OnError(NancyContext context, Exception exception) { var contextData = new Dictionary<string, object> { { NANCY_CONTEXT, context } }; ExceptionlessClient.Current.ProcessUnhandledException(exception, "NancyPipelineException", true, contextData); return context.Response; }
private void AttachErrorResponse(NancyContext ctx) { if (ctx.ModelValidationResult.Errors.Count > 0) { ctx.Response.StatusCode = HttpStatusCode.BadRequest; } }
private string GetHtmlLinks(NancyContext context) { var routeCache = this.routeCacheProvider.GetCache(); if (routeCache == null) return String.Empty; StringBuilder linkBuilder = new StringBuilder(); var routesWithMetadata = routeCache .Select(r => r.Value) .SelectMany(r => r.Select(t => t.Item2)) .Where(r => r.Metadata != null && r.Metadata.Has<PomonaRouteMetadata>()); foreach (var route in routesWithMetadata) { var metadata = route.Metadata.Retrieve<PomonaRouteMetadata>(); var rel = String.Concat("http://pomona.io/rel/", metadata.Relation); var contentType = metadata.ContentType; var methods = metadata.Method.ToString().ToUpperInvariant(); var href = context.Request.Url.BasePath + route.Path; linkBuilder.AppendFormat("<link rel=\"{0}\" type=\"{1}\" methods=\"{2}\" href=\"{3}\">{4}", rel, contentType, methods, href, Environment.NewLine); } return linkBuilder.ToString(); }
protected override void ConfigureRequestContainer(TinyIoCContainer container, NancyContext context) { base.ConfigureRequestContainer(container, context); var ctx = new SmartFlowContext(); container.Register(ctx); container.Register<IUserMapper, SmartFlowAuthService>(); }
public Response Handle(NancyContext context) { try { var response = HandlePactRequest(context); return response; } catch (Exception ex) { var exceptionMessage = ex.Message .Replace("\r", " ") .Replace("\n", "") .Replace("\t", " ") .Replace(@"\", ""); var errorResponse = new ProviderServiceResponse { Status = 500, Body = exceptionMessage }; var response = _responseMapper.Convert(errorResponse); response.ReasonPhrase = exceptionMessage; return response; } }
public void RewriteResponseContents(NancyContext context) { if (!context.Response.ContentType.Equals("text/html")) { // Only html needs to be (possibly) rewritten return; } var currentContents = context.Response.Contents; context.Response.Contents = stream => { var placeholderTracker = Container.Resolve<IPlaceholderTracker>(); var currentContentsStream = new MemoryStream(); currentContents(currentContentsStream); var reader = new StreamReader(currentContentsStream); reader.BaseStream.Seek(0, SeekOrigin.Begin); var writer = new StreamWriter(stream); writer.Write(placeholderTracker.ReplacePlaceholders(reader.ReadToEnd())); writer.Flush(); }; }
protected override void RequestStartup(IWindsorContainer container, IPipelines pipelines, NancyContext context) { base.RequestStartup(container, pipelines, context); pipelines.BeforeRequest.AddItemToEndOfPipeline(nancyContext => { this.Info(() => "Monitoring API invoked at {0}[{1}]".FormatWith(nancyContext.Request.Method, nancyContext.Request.Url)); var token = ""; var cookie = nancyContext.Request.Headers.Cookie.FirstOrDefault(x => (x.Name + "").ToLower() == "token"); if (cookie != null) token = HttpUtility.UrlDecode(cookie.Value); nancyContext.Request.Headers.Authorization = "Token {0}".FormatWith(token); var user = container.Resolve<ITokenizer>().Detokenize(token, nancyContext, new DefaultUserIdentityResolver()); if (user != null) { nancyContext.CurrentUser = user; } return null; }); pipelines.OnError.AddItemToEndOfPipeline((nancyContext, exception) => { this.Error(() => "Error on Monitoring request {0}[{1}] => {2}".FormatWith(nancyContext.Request.Method, nancyContext.Request.Url, exception)); return ErrorResponse.FromException(exception); }); TokenAuthentication.Enable(pipelines, new TokenAuthenticationConfiguration(container.Resolve<ITokenizer>())); pipelines.OnError.AddItemToEndOfPipeline((nancyContext, exception) => { this.Error(() => "Error on Monitoring request {0}[{1}] => {2}".FormatWith(nancyContext.Request.Method, nancyContext.Request.Url, exception)); return ErrorResponse.FromException(exception); }); }
static object GetMember( NancyContext context, IDocumentSession documentSession, string alias) { if (context == null) throw new ArgumentNullException("context"); if (documentSession == null) throw new ArgumentNullException("documentSession"); if (String.IsNullOrEmpty(alias)) return 404; if (!context.IsSignedUp()) return 403; var member = documentSession.GetMemberByAlias(alias); if (member == null) return 404; var currentMember = context.GetCurrentMember(documentSession); Debug.Assert(currentMember != null, "`requireSignedUp()` should ensure the current member is not null."); if (!member.Alias.Equals(currentMember.Alias, StringComparison.OrdinalIgnoreCase)) return 403; var rooms = documentSession.GetRoomsByOwner(member.Id); return new MemberResponse(member, rooms); }
/// <summary> /// Adds the current response to the cache if required /// Only stores by Path and stores the response in a dictionary. /// Do not use this as an actual cache :-) /// </summary> /// <param name="context">Current context</param> public void SetCache(NancyContext context) { if (context.Response.StatusCode != HttpStatusCode.OK) { return; } object cacheSecondsObject; if (!context.Items.TryGetValue(ContextExtensions.OUTPUT_CACHE_TIME_KEY, out cacheSecondsObject)) { return; } int cacheSeconds; if (!int.TryParse(cacheSecondsObject.ToString(), out cacheSeconds)) { return; } var cachedResponse = new CachedResponse(context.Response); this.cachedResponses[context.Request.Path] = new Tuple<DateTime, Response, int>(DateTime.Now, cachedResponse, cacheSeconds); context.Response = cachedResponse; }
protected override void ConfigureRequestContainer(TinyIoCContainer container, NancyContext context) { base.ConfigureRequestContainer(container, context); container.Register<IUserMapper, FakeRepository>(); container.Register<IRepository, FakeRepository>(); }
public IUserIdentity GetUserFromIdentifier(Guid identifier, NancyContext context) { string userGuid = identifier.ToString(); var user = this.Repository.Find<User>(x => x.Guid == userGuid).SingleOrDefault(); return user == null ? null : new PlayerIdentity() { UserName = user.Id.ToString() }; }
public void CacheCheck(NancyContext context) { var responseHeaders = context.Response.Headers; var requestHeaders = context.Request.Headers; string currentFileEtag; if (responseHeaders.TryGetValue("ETag", out currentFileEtag)) { if (requestHeaders.IfNoneMatch.Contains(currentFileEtag)) { context.Response = HttpStatusCode.NotModified; return; } } string responseLastModifiedString; if (responseHeaders.TryGetValue("Last-Modified", out responseLastModifiedString)) { var responseLastModified = DateTime.ParseExact(responseLastModifiedString, "R", CultureInfo.InvariantCulture, DateTimeStyles.None); if (responseLastModified <= requestHeaders.IfModifiedSince) { context.Response = HttpStatusCode.NotModified; } } }
public ResolveResult Resolve(NancyContext context) { var results = this.trie.GetMatches(GetMethod(context), context.Request.Path, context); if (!results.Any()) { if (this.IsOptionsRequest(context)) { return this.BuildOptionsResult(context); } return this.GetNotFoundResult(context); } // Sort in descending order Array.Sort(results, (m1, m2) => -m1.CompareTo(m2)); for (var index = 0; index < results.Length; index++) { var matchResult = results[index]; if (matchResult.Condition == null || matchResult.Condition.Invoke(context)) { return this.BuildResult(context, matchResult); } } return this.GetNotFoundResult(context); }
public bool HandlesStatusCode(Nancy.HttpStatusCode statusCode, Nancy.NancyContext context) { return ((statusCode == HttpStatusCode.Forbidden) || (statusCode == HttpStatusCode.NotFound) || (statusCode == HttpStatusCode.InternalServerError) || (statusCode == HttpStatusCode.Locked)); }
public void Handle(Nancy.HttpStatusCode statusCode, Nancy.NancyContext context) { var response = viewRenderer.RenderView(context, "Error", new ErrorViewModel { Code = (int)statusCode }); response.StatusCode = statusCode; context.Response = response; }
private ResolveResult CreateRouteAndParametersFromMatch(NancyContext context, RouteCandidate routeMatchToReturn) { var associatedModule = this.GetInitializedModuleForMatch(context, routeMatchToReturn); var route = associatedModule.Routes.ElementAt(routeMatchToReturn.Item2); return(new ResolveResult(route, routeMatchToReturn.Item4.Parameters, associatedModule.Before, associatedModule.After, associatedModule.OnError)); }
private void ModifyResult(Nancy.NancyContext ctx) { var myIndexWatch = Int32.Parse(ctx.Items["X-watch"].ToString()); lock (_lock) { var myWatch = _watch[myIndexWatch]; myWatch.Stop(); var elapsedMs = myWatch.ElapsedMilliseconds; _watch.RemoveAt(myIndexWatch); Console.WriteLine(ctx.Request.Method + " " + ctx.Request.Path + ": " + elapsedMs + " miliseconds"); } }
private void SetCookieDomain(Nancy.NancyContext ctx) { string domainName = System.Configuration.ConfigurationManager.AppSettings["Domain"]; if (domainName == null || domainName.Trim() == string.Empty) { return; } foreach (Nancy.Cookies.INancyCookie cookie in ctx.Response.Cookies) { cookie.Domain = domainName; } }
private Nancy.Response CheckSomething(Nancy.NancyContext ctx) { var watch = System.Diagnostics.Stopwatch.StartNew(); lock (_lock) { _watch.Add(watch); _watch.Insert(nextId, watch); ctx.Items.Add("X-watch", nextId); nextId++; } // if you return null, nancy will proceed to module return(null); }
HttpClient CreateProxyClient(Nancy.NancyContext context) { var handler = new HttpClientHandler(); handler.AllowAutoRedirect = false; var client = new HttpClient(handler); foreach (var header in Context.Request.Headers) { //Log.Debug("{key}: {value}", header.Key, header.Value); if (_skipHeaders.Contains(header.Key)) // host header causes 400 invalid host error { continue; } client.DefaultRequestHeaders.Add(header.Key, header.Value); } // client.DefaultRequestHeaders.Add("X-Forwarded-For", <UserHostAddress>); // TODO: see RequestLogEnricher.GetUserIPAddress() client.DefaultRequestHeaders.Add("X-Compute-Id", Context.Items["RequestId"] as string); client.DefaultRequestHeaders.Add("X-Compute-Host", Context.Items["Hostname"] as string); return(client); }
Nancy.Response CreateProxyResponse(HttpResponseMessage backendResponse, Nancy.NancyContext context) { string responseBody = backendResponse.Content.ReadAsStringAsync().Result; var response = (Nancy.Response)responseBody; response.StatusCode = (Nancy.HttpStatusCode)backendResponse.StatusCode; foreach (var header in backendResponse.Headers) { foreach (var value in header.Value) { response.Headers.Add(header.Key, value); } } foreach (var header in backendResponse.Content.Headers) { foreach (var value in header.Value) { response.Headers.Add(header.Key, value); } } return(response); }
private bool EnableTracing(NancyContext ctx) { return(StaticConfiguration.EnableRequestTracing && !ctx.Items.ContainsKey(DiagnosticsHook.ItemsKey)); }
/// <summary> /// Check if the error handler can handle errors of the provided status code. /// </summary> /// <param name="statusCode">The HTTP status code.</param> /// <param name="context">The <see cref="NancyContext" /> instance of the current request.</param> /// <returns> /// <c>true</c> if if the instance handles the specified HTTP status code. /// </returns> public bool HandlesStatusCode(HttpStatusCode statusCode, Nancy.NancyContext context) { return(statusCode == HttpStatusCode.NotFound || statusCode == HttpStatusCode.InternalServerError); }
protected override void ConfigureRequestContainer(TinyIoCContainer _container, Nancy.NancyContext _context) { base.ConfigureRequestContainer(_container, _context); _container.Register <IUserMapper, UserMapper>(); }
protected override void ConfigureRequestContainer( Nancy.TinyIoc.TinyIoCContainer container, Nancy.NancyContext context) { base.ConfigureRequestContainer(container, context); }
public static string GetLastName(this Nancy.NancyContext context) => context.CurrentUser?.FindFirst(_ => _.Type == "family_name")?.Value;
public ResolveResult Resolve(NancyContext context) { AreaConfigs areaConfigs; // We are leveraging sort of a hack of Nancy's routing system. Protect from direct access to internal paths. if (context.Request.Path.StartsWith(Constants.ResolverAreaPrefix) || context.Request.Path.StartsWith(Constants.ResolverAdminAreaPrefix)) { return(new ResolveResult(new NotFoundRoute(context.Request.Method, context.Request.Path), DynamicDictionary.Empty, null, null, null)); } // First, try resolving the admin area. By convention, it is always "admin/areaName/path", where "admin" is configurable if (context.Request.Path.StartsWith(AreasResolver.Instance.AdminAreaPrefix)) { String areaName; var path = context.Request.Path.Substring(AreasResolver.Instance.AdminAreaPrefix.Length); int pos = path.IndexOf('/', 1); if (pos > 1) { areaName = path.Substring(1, pos - 1); path = path.Substring(pos); } else { areaName = path.Substring(1); path = "/"; } // Core admin modules take precedence over user modules if (!NSembleCoreAdminModule.AvailableModules.TryGetValue(areaName, out areaConfigs)) { areaConfigs = AreasResolver.Instance.GetAreaConfigsByName(areaName); } if (areaConfigs == null) { return(new ResolveResult(new NotFoundRoute(context.Request.Method, context.Request.Path), DynamicDictionary.Empty, null, null, null)); } context.Items.Add("AreaConfigs", areaConfigs); var ret = Resolve(string.Concat(Constants.ResolverAdminAreaPrefix, "/", areaConfigs.ModuleName, path), context, this.cache); return(ret.Selected); } var remainingPath = AreasResolver.Instance.ParseArea(context.Request.Path, out areaConfigs); if (areaConfigs == null) { // basically, a 404 return(new ResolveResult(new NotFoundRoute(context.Request.Method, context.Request.Path), DynamicDictionary.Empty, null, null, null)); } context.Items.Add("AreaConfigs", areaConfigs); var newPath = string.Concat(Constants.ResolverAreaPrefix, "/", areaConfigs.ModuleName, remainingPath); var result = this.Resolve(newPath, context, this.cache); return(result.Selected); }
private ResolveResults Resolve(string path, NancyContext context, IRouteCache routeCache) { if (routeCache.IsEmpty()) { context.Trace.TraceLog.WriteLog(s => s.AppendLine("[DefaultRouteResolver] No routes available")); return(new ResolveResults { Selected = new ResolveResult(new NotFoundRoute(context.Request.Method, path), DynamicDictionary.Empty, null, null, null) }); } var routes = routeCache.GetRouteCandidates(); // Condition routes = routes.Filter(context, "Invalid condition", (ctx, route) => { var validCondition = ((route.Item3.Condition == null) || (route.Item3.Condition(ctx))); return(new Tuple <bool, RouteCandidate>( validCondition, route )); }); if (!routes.Item1.Any()) { context.Trace.TraceLog.WriteLog(s => s.AppendLine("[DefaultRouteResolver] No route had a valid condition")); return(new ResolveResults { Selected = new ResolveResult(new NotFoundRoute(context.Request.Method, path), DynamicDictionary.Empty, null, null, null), Rejected = routes.Item2 }); } // Path routes = routes.Filter(context, "Path did not match", (ctx, route) => { var validationResult = this.routePatternMatcher.Match(path, route.Item3.Path, route.Item3.Segments, context); var routeToReturn = (validationResult.IsMatch) ? new RouteCandidate(route.Item1, route.Item2, route.Item3, validationResult) : route; return(new Tuple <bool, RouteCandidate>( validationResult.IsMatch, routeToReturn )); }); if (!routes.Item1.Any()) { context.Trace.TraceLog.WriteLog(s => s.AppendLine("[DefaultRouteResolver] No route matched the requested path")); return(new ResolveResults { Selected = new ResolveResult(new NotFoundRoute(context.Request.Method, path), DynamicDictionary.Empty, null, null, null), Rejected = routes.Item2 }); } // Method routes = routes.Filter(context, "Request method did not match", (ctx, route) => { var routeMethod = route.Item3.Method.ToUpperInvariant(); var requestMethod = ctx.Request.Method.ToUpperInvariant(); var methodIsValid = routeMethod.Equals(requestMethod) || (routeMethod.Equals("GET") && requestMethod.Equals("HEAD")); return(new Tuple <bool, RouteCandidate>( methodIsValid, route )); }); if (!routes.Item1.Any()) { var allowedMethods = routes.Item2.Values.SelectMany(x => x.Select(y => y.Item3.Method)).Distinct(); if (context.Request.Method.Equals("OPTIONS")) { return(new ResolveResults { Selected = new ResolveResult(new OptionsRoute(context.Request.Path, allowedMethods), DynamicDictionary.Empty, null, null, null), Rejected = routes.Item2 }); } context.Trace.TraceLog.WriteLog(s => s.AppendLine("[DefaultRouteResolver] Route Matched But Method Not Allowed")); return(new ResolveResults { Selected = new ResolveResult(new MethodNotAllowedRoute(path, context.Request.Method, allowedMethods), DynamicDictionary.Empty, null, null, null), Rejected = routes.Item2 }); } // Exact match var exactMatchResults = routes.Filter(context, "No exact match", (ctx, route) => { var routeIsExactMatch = !route.Item4.Parameters.GetDynamicMemberNames().Any(); return(new Tuple <bool, RouteCandidate>( routeIsExactMatch, route )); }); if (exactMatchResults.Item1.Any()) { context.Trace.TraceLog.WriteLog(s => s.AppendLine("[DefaultRouteResolver] Found exact match route")); return(new ResolveResults { Selected = this.CreateRouteAndParametersFromMatch(context, exactMatchResults.Item1.First()), Rejected = exactMatchResults.Item2 }); } // First match out of multiple candidates var selected = GetTopRouteMatchesNew(routes).First(); context.Trace.TraceLog.WriteLog(s => s.AppendLine("[DefaultRouteResolver] Selected best match")); return(new ResolveResults { Selected = this.CreateRouteAndParametersFromMatch(context, selected), Rejected = exactMatchResults.Item2 }); }
public bool HandlesStatusCode(Nancy.HttpStatusCode statusCode, Nancy.NancyContext context) { return((int)statusCode >= 400); }
/// <summary> /// Executes at the end of the nancy execution pipeline and before control is passed back to the hosting. /// Can be used to pre-render/validate views while still inside the main pipeline/error handling. /// </summary> /// <param name="context">Nancy context</param> /// <returns>Task for completion/erroring</returns> public virtual Task PreExecute(NancyContext context) { return(TaskHelpers.GetCompletedTask()); }
private void UpdateTraceCookie(NancyContext ctx, Guid sessionGuid) { var cookie = new NancyCookie("__NCTRACE", sessionGuid.ToString(), true) { Expires = DateTime.Now.AddMinutes(30) }; ctx.Response.AddCookie(cookie); }
private Task InvokePostRequestHook(NancyContext context, CancellationToken cancellationToken, AfterPipeline pipeline) { return(pipeline == null?TaskHelpers.GetCompletedTask() : pipeline.Invoke(context, cancellationToken)); }
private bool EnableTracing(NancyContext ctx) { return StaticConfiguration.EnableRequestTracing && !ctx.Request.Path.StartsWith(DiagnosticsHook.ControlPanelPrefix); }
private static Action <Task <Response> > ExecuteTasksWithSingleResultContinuation(NancyContext context, CancellationToken cancellationToken, IEnumerator <Func <NancyContext, CancellationToken, Task <Response> > > enumerator, TaskCompletionSource <Response> tcs) { return(t => { if (ContinueExecution(t.IsFaulted, t.Result, t.Exception)) { if (enumerator.MoveNext()) { ExecuteTasksWithSingleResultInternal(context, cancellationToken, enumerator, tcs); } else { ExecuteTasksSingleResultFinished(null, tcs); } } else { ExecuteTasksSingleResultFinished(t, tcs); } }); }
private Response LogRequest(NancyContext ctx) { _logger.Debug("************ Request ************"); _logger.Debug("{0} - {1}", ctx.Request.Method, ctx.Request.Path); _logger.Debug("************ Headers ************"); foreach(var headerGroup in ctx.Request.Headers) { foreach(var header in headerGroup.Value) { _logger.Debug("{0} - {1}", headerGroup.Key, header); } } _logger.Debug("************ Body ************"); using (var reader = new StreamReader(ctx.Request.Body)) { var content = reader.ReadToEnd(); _logger.Debug(HttpUtility.UrlDecode(content)); } ctx.Request.Body.Position = 0; return null; }