/// <inheritdoc /> protected override Task WriteFileAsync(HttpResponse response) { var bufferingFeature = response.HttpContext.Features.Get<IHttpBufferingFeature>(); bufferingFeature?.DisableResponseBuffering(); return response.Body.WriteAsync(FileContents, offset: 0, count: FileContents.Length); }
/// <inheritdoc /> protected override async Task WriteFileAsync(HttpResponse response, CancellationToken cancellation) { if (!Path.IsPathRooted(FileName)) { throw new FileNotFoundException(Resources.FormatFileResult_InvalidPath(FileName), FileName); } var sendFile = response.HttpContext.Features.Get<IHttpSendFileFeature>(); if (sendFile != null) { await sendFile.SendFileAsync( FileName, offset: 0, length: null, cancellation: cancellation); return; } else { var fileStream = GetFileStream(FileName); using (fileStream) { await fileStream.CopyToAsync(response.Body, DefaultBufferSize, cancellation); } return; } }
public StaticFileContext(HttpContext context, StaticFileOptions options, PathString matchUrl, ILogger logger) { _context = context; _options = options; _matchUrl = matchUrl; _request = context.Request; _response = context.Response; _logger = logger; _requestHeaders = _request.GetTypedHeaders(); _responseHeaders = _response.GetTypedHeaders(); _method = null; _isGet = false; _isHead = false; _subPath = PathString.Empty; _contentType = null; _fileInfo = null; _length = 0; _lastModified = new DateTimeOffset(); _etag = null; _ifMatchState = PreconditionState.Unspecified; _ifNoneMatchState = PreconditionState.Unspecified; _ifModifiedSinceState = PreconditionState.Unspecified; _ifUnmodifiedSinceState = PreconditionState.Unspecified; _ranges = null; }
/// <inheritdoc /> protected override async Task WriteFileAsync(HttpResponse response) { if (!Path.IsPathRooted(FileName)) { throw new NotSupportedException(Resources.FormatFileResult_PathNotRooted(FileName)); } var sendFile = response.HttpContext.Features.Get<IHttpSendFileFeature>(); if (sendFile != null) { await sendFile.SendFileAsync( FileName, offset: 0, length: null, cancellation: default(CancellationToken)); } else { var fileStream = GetFileStream(FileName); using (fileStream) { await fileStream.CopyToAsync(response.Body, DefaultBufferSize); } } }
internal static HttpResponsePacket ToHttpResponse(HttpResponse response, ServiceMessage msg) { var rsp = new HttpResponsePacket(); foreach (var hdr in response.Headers) { // TODO: Fix adding response headers //AddHttpHeader(hdr); } //TODO: Decide if to read mostly from ServiceMessage or from response. //rsp.Version = response.... //TODO: Add a default version here rsp.StatusCode = (int)response.StatusCode; rsp.StatusDescription = ((IHttpResponseFeature)msg).ReasonPhrase; if (response.Body != null) { using (MemoryStream ms = new MemoryStream()) { response.Body.Position = 0; response.Body.CopyTo(ms); rsp.Content = ms.ToArray(); } } return rsp; }
/// <inheritdoc /> protected override Task WriteFileAsync(HttpResponse response, CancellationToken cancellation) { var bufferingFeature = response.HttpContext.Features.Get<IHttpBufferingFeature>(); bufferingFeature?.DisableResponseBuffering(); return response.Body.WriteAsync(FileContents, 0, FileContents.Length, cancellation); }
/// <inheritdoc /> protected async override Task WriteFileAsync(HttpResponse response, CancellationToken cancellation) { var outputStream = response.Body; using (FileStream) { await FileStream.CopyToAsync(outputStream, BufferSize, cancellation); } }
private void SetCacheHeaders(HttpResponse response) { if (_options.CacheLength != null) { var expires = DateTime.Now.AddSeconds(_options.CacheLength.TotalSeconds); response.Headers.SetCommaSeparatedValues("Cache-Control", "public", $"max-age={_options.CacheLength.TotalSeconds}"); response.Headers.Set("Expires", expires.ToUniversalTime().ToString("R")); } }
private void RespondWithSwaggerJson(HttpResponse response, SwaggerDocument swagger) { response.StatusCode = 200; response.ContentType = "application/json"; using (var writer = new StreamWriter(response.Body)) { _swaggerSerializer.Serialize(writer, swagger); } }
private void SerializeResponseObject(HttpResponse response, object value) { using (var writer = new StreamWriter(response.Body)) { using (var jsonWriter = new JsonTextWriter(writer)) { jsonWriter.CloseOutput = false; var jsonSerializer = JsonSerializer.Create(/*TODO: SerializerSettings*/); jsonSerializer.Serialize(jsonWriter, value); } } }
/// <inheritdoc /> protected async override Task WriteFileAsync(HttpResponse response, CancellationToken cancellation) { var outputStream = response.Body; using (FileStream) { var bufferingFeature = response.HttpContext.Features.Get<IHttpBufferingFeature>(); bufferingFeature?.DisableResponseBuffering(); await FileStream.CopyToAsync(outputStream, BufferSize, cancellation); } }
internal static Task WriteResponseBodyAsync(HttpResponse response, string uid, DateTimeOffset? datetime, TimeSpan? duration, string summary, string description, string location) { return response.WriteAsync( "BEGIN:VCALENDAR\r\n" + "VERSION:2.0\r\n" + "BEGIN:VEVENT\r\n" + "UID:" + uid + "\r\n" + "DTSTART:" + datetime?.ToString(DateTimeFormat) + "\r\n" + "DTEND:" + datetime?.Add(duration ?? TimeSpan.Zero).ToString(DateTimeFormat) + "\r\n" + "SUMMARY:" + summary + "\r\n" + "DESCRIPTION:" + description + "\r\n" + "LOCATION:" + location + "END:VEVENT\r\n" + "END:VCALENDAR\r\n"); }
public static void AddLocationHeaderToMapping( HttpResponse response, IDictionary<string, string> contentIdToLocationMapping, string contentId) { //Contract.Assert(response != null); //Contract.Assert(contentIdToLocationMapping != null); //Contract.Assert(contentId != null); //if (response.Headers.Location != null) //{ // contentIdToLocationMapping.Add(contentId, response.Headers.Location.AbsoluteUri); //} throw new NotImplementedException("AddLocationHeaderToMapping"); }
public static async Task WriteOutput(HttpResponse Response, string Title, Head.Tag[] HeadTags, string Body) { var sb = new StringBuilder(); sb.Append("<!DOCTYPE html><head><meta charset=\"utf-8\">"); if (Title != null) { sb.Append("<title>" + Title + "</title>"); } if (HeadTags != null) { foreach (var a in HeadTags) { sb.Append(a.Output()); } } sb.Append("</head><body>"); sb.Append(Body); sb.Append("</body></html>"); await Response.WriteAsync(sb.ToString()); }
/// <inheritdoc /> protected override Task WriteFileAsync(HttpResponse response, CancellationToken cancellation) { var fileProvider = GetFileProvider(response.HttpContext.RequestServices); var resolveFilePathResult = ResolveFilePath(fileProvider); if (resolveFilePathResult.PhysicalFilePath != null) { return CopyPhysicalFileToResponseAsync(response, resolveFilePathResult.PhysicalFilePath, cancellation); } else { // Example: An embedded resource var sourceStream = resolveFilePathResult.FileInfo.CreateReadStream(); return CopyStreamToResponseAsync(sourceStream, response, cancellation); } }
private static ActionContext CreateMockActionContext( HttpResponse response = null, string requestAcceptHeader = "application/*", string requestContentType = "application/json", string requestAcceptCharsetHeader = "", bool respectBrowserAcceptHeader = false) { var httpContext = new Mock<HttpContext>(); if (response != null) { httpContext.Setup(o => o.Response).Returns(response); } var content = "{name: 'Person Name', Age: 'not-an-age'}"; var contentBytes = Encoding.UTF8.GetBytes(content); var request = new DefaultHttpContext().Request; request.Headers["Accept-Charset"] = requestAcceptCharsetHeader; request.Headers["Accept"] = requestAcceptHeader; request.ContentType = requestContentType; request.Body = new MemoryStream(contentBytes); httpContext.Setup(o => o.Request).Returns(request); httpContext.Setup(o => o.RequestServices).Returns(GetServiceProvider()); var optionsAccessor = new MockMvcOptionsAccessor(); optionsAccessor.Options.OutputFormatters.Add(new StringOutputFormatter()); optionsAccessor.Options.OutputFormatters.Add(new JsonOutputFormatter()); optionsAccessor.Options.RespectBrowserAcceptHeader = respectBrowserAcceptHeader; var mockContextAccessor = new Mock<IScopedInstance<ActionBindingContext>>(); mockContextAccessor .SetupGet(o => o.Value) .Returns(new ActionBindingContext() { OutputFormatters = optionsAccessor.Options.OutputFormatters }); httpContext.Setup(o => o.RequestServices.GetService(typeof(IScopedInstance<ActionBindingContext>))) .Returns(mockContextAccessor.Object); httpContext.Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>))) .Returns(optionsAccessor); httpContext.Setup(o => o.RequestServices.GetService(typeof(ILogger<ObjectResult>))) .Returns(new Mock<ILogger<ObjectResult>>().Object); return new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor()); }
public Core(Server server, HttpContext context, string viewstate = "", string type = "") { Server = server; Context = context; Request = context.Request; Response = context.Response; Session = context.Session; Sql = new Sql(this); Util = new Utility.Util(this); User = new User(); //load viewstate if (useViewState == true) { ViewStateId = viewstate; if(ViewStateId == "") { ViewStateId = Util.Str.CreateID(); } if (Session["viewstate-" + ViewStateId] != null) { ViewState vs = new ViewState(); vs = (ViewState)Util.Serializer.ReadObject(Util.Str.GetString(Session["viewstate-" + ViewStateId]), vs.GetType()); Page = vs.Page; Elements = new Elements(this, Page.themeFolder); }else { Page = new Page(); } }else { Page = new Page(); } if (Session["user"] != null) { User = (User)Util.Serializer.ReadObject(Util.Str.GetString(Session["user"]), User.GetType()); } //load references to Core R Sql.Load(); Page.Load(this); User.Load(this); //generate visitor id if (User.visitorId == "" || User.visitorId == null) { User.visitorId = Util.Str.CreateID(); } //detect request type & host type if (type == "service") { isWebService = true; } if (Request.Host.Value.IndexOf("localhost") >= 0 || Request.Host.Value.IndexOf("192.168.") >= 0) { isLocal = true; } }
/// <inheritdoc /> protected override async Task WriteFileAsync(HttpResponse response, CancellationToken cancellation) { var fileProvider = GetFileProvider(response.HttpContext.RequestServices); var normalizedPath = FileName; if (normalizedPath.StartsWith("~")) { normalizedPath = normalizedPath.Substring(1); } var fileInfo = fileProvider.GetFileInfo(normalizedPath); if (fileInfo.Exists) { var physicalPath = fileInfo.PhysicalPath; var sendFile = response.HttpContext.Features.Get<IHttpSendFileFeature>(); if (sendFile != null && !string.IsNullOrEmpty(physicalPath)) { await sendFile.SendFileAsync( physicalPath, offset: 0, length: null, cancellation: cancellation); return; } else { var fileStream = GetFileStream(fileInfo); using (fileStream) { await fileStream.CopyToAsync(response.Body, DefaultBufferSize, cancellation); } return; } } throw new FileNotFoundException( Resources.FormatFileResult_InvalidPath(FileName), FileName); }
private static ActionContext CreateMockActionContext( HttpResponse response = null, string requestAcceptHeader = "application/*", string requestContentType = "application/json", string requestAcceptCharsetHeader = "", bool respectBrowserAcceptHeader = false) { var formatters = new IOutputFormatter[] { new StringOutputFormatter(), new JsonOutputFormatter() }; var httpContext = new Mock<HttpContext>(); if (response != null) { httpContext.Setup(o => o.Response).Returns(response); } var content = "{name: 'Person Name', Age: 'not-an-age'}"; var contentBytes = Encoding.UTF8.GetBytes(content); var request = new DefaultHttpContext().Request; request.Headers["Accept-Charset"] = requestAcceptCharsetHeader; request.Headers["Accept"] = requestAcceptHeader; request.ContentType = requestContentType; request.Body = new MemoryStream(contentBytes); httpContext.Setup(o => o.Request).Returns(request); httpContext.Setup(o => o.RequestServices).Returns(GetServiceProvider()); httpContext.Setup(o => o.RequestServices.GetService(typeof(IOutputFormattersProvider))) .Returns(new TestOutputFormatterProvider(formatters)); var options = new Mock<IOptions<MvcOptions>>(); options.SetupGet(o => o.Options) .Returns(new MvcOptions() { RespectBrowserAcceptHeader = respectBrowserAcceptHeader }); httpContext.Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>))) .Returns(options.Object); return new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor()); }
public IBookshelfSession GetSession(HttpResponse response,string userName, string clientId,string userEmail) { var hashCode = GetSessionHashCode(userName, clientId); IBookshelfSession session; var sessionFound = _sessions.TryGetValue(hashCode, out session); if (sessionFound && session.IsExpired()) { //remove expired session - IsExpired removes expired session by it's call //esnure session not found workflow is going to be applied sessionFound = false; } //if there is no such session in storage, or there is but it's expired - create new one if (!sessionFound) { var userInfo = new InSessionUserInfo { UserEmail = userEmail, UserClientId = clientId, UserName = userName }; session = CreateServerSession(hashCode, userInfo,response); //check if there is proper active device alreadybeen created if (_cache.Get(userName) != null) { Dictionary<string, IBookshelfSession> deviceSessions = (Dictionary<string, IBookshelfSession>) _cache.Get(userName); if (!deviceSessions.ContainsKey(clientId)) { deviceSessions.Add(clientId, session); } } else { _cache.Set(userName, new Dictionary<string, IBookshelfSession> { { clientId, session } }); } } return session; }
private static ActionContext CreateMockActionContext( IEnumerable<IOutputFormatter> outputFormatters, HttpResponse response = null, string requestAcceptHeader = "application/*", string requestContentType = "application/json", string requestAcceptCharsetHeader = "", bool respectBrowserAcceptHeader = false, bool setupActionBindingContext = true) { var httpContext = new Mock<HttpContext>(); if (response != null) { httpContext.Setup(o => o.Response).Returns(response); } var content = "{name: 'Person Name', Age: 'not-an-age'}"; var contentBytes = Encoding.UTF8.GetBytes(content); var request = new DefaultHttpContext().Request; request.Headers["Accept-Charset"] = requestAcceptCharsetHeader; request.Headers["Accept"] = requestAcceptHeader; request.ContentType = requestContentType; request.Body = new MemoryStream(contentBytes); httpContext.Setup(o => o.Request).Returns(request); httpContext.Setup(o => o.RequestServices).Returns(GetServiceProvider()); var optionsAccessor = new MockMvcOptionsAccessor(); foreach (var formatter in outputFormatters) { optionsAccessor.Options.OutputFormatters.Add(formatter); } optionsAccessor.Options.RespectBrowserAcceptHeader = respectBrowserAcceptHeader; httpContext.Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>))) .Returns(optionsAccessor); httpContext.Setup(o => o.RequestServices.GetService(typeof(ILogger<ObjectResult>))) .Returns(new Mock<ILogger<ObjectResult>>().Object); ActionBindingContext actionBindingContext = null; if (setupActionBindingContext) { actionBindingContext = new ActionBindingContext { OutputFormatters = outputFormatters.ToList() }; } httpContext.Setup(o => o.RequestServices.GetService(typeof(IActionBindingContextAccessor))) .Returns(new ActionBindingContextAccessor() { ActionBindingContext = actionBindingContext }); return new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor()); }
public async Task WriteOtherSettingsAsync(HttpResponse response) { await response.WriteAsync( $"OtherSettings Strings: {string.Join(", ", _otherSettings.Strings)}<br>" + $"OtherSettings Numbers: {string.Join(", ", _otherSettings.Numbers)}"); }
private static ActionContext CreateMockActionContext( HttpResponse response = null, string requestAcceptHeader = "application/*", string requestContentType = "application/json", string requestAcceptCharsetHeader = "", bool respectBrowserAcceptHeader = false) { var formatters = new IOutputFormatter[] { new StringOutputFormatter(), new JsonOutputFormatter() }; return CreateMockActionContext( formatters, response: response, requestAcceptHeader: requestAcceptHeader, requestContentType: requestContentType, requestAcceptCharsetHeader: requestAcceptCharsetHeader, respectBrowserAcceptHeader: respectBrowserAcceptHeader); }
private void RespondWithContentHtml(HttpResponse response, Stream content) { response.StatusCode = 200; response.ContentType = "text/html"; content.CopyTo(response.Body); }
/// <inheritdoc /> public virtual void ApplyResult(CorsResult result, HttpResponse response) { var headers = response.Headers; if (result.AllowedOrigin != null) { headers.Add(CorsConstants.AccessControlAllowOrigin, new[] { result.AllowedOrigin }); } if (result.VaryByOrigin) { headers.Set("Vary", "Origin"); } if (result.SupportsCredentials) { headers.Add(CorsConstants.AccessControlAllowCredentials, new[] { "true" }); } if (result.AllowedMethods.Count > 0) { // Filter out simple methods var nonSimpleAllowMethods = result.AllowedMethods .Where(m => !CorsConstants.SimpleMethods.Contains(m, StringComparer.OrdinalIgnoreCase)) .ToArray(); if (nonSimpleAllowMethods.Length > 0) { headers.SetCommaSeparatedValues( CorsConstants.AccessControlAllowMethods, nonSimpleAllowMethods); } } if (result.AllowedHeaders.Count > 0) { // Filter out simple request headers var nonSimpleAllowRequestHeaders = result.AllowedHeaders .Where(header => !CorsConstants.SimpleRequestHeaders.Contains(header, StringComparer.OrdinalIgnoreCase)) .ToArray(); if (nonSimpleAllowRequestHeaders.Length > 0) { headers.SetCommaSeparatedValues( CorsConstants.AccessControlAllowHeaders, nonSimpleAllowRequestHeaders); } } if (result.AllowedExposedHeaders.Count > 0) { // Filter out simple response headers var nonSimpleAllowResponseHeaders = result.AllowedExposedHeaders .Where(header => !CorsConstants.SimpleResponseHeaders.Contains(header, StringComparer.OrdinalIgnoreCase)) .ToArray(); if (nonSimpleAllowResponseHeaders.Length > 0) { headers.SetCommaSeparatedValues( CorsConstants.AccessControlExposeHeaders, nonSimpleAllowResponseHeaders); } } if (result.PreflightMaxAge.HasValue) { headers.Set( CorsConstants.AccessControlMaxAge, result.PreflightMaxAge.Value.TotalSeconds.ToString()); } }
public static async Task WriteJsonAsync(this HttpResponse response, object o) { var json = JsonConvert.SerializeObject(o, settings); await response.WriteJsonAsync(json); }
private static void Describe(HttpResponse res, AuthenticateContext result) { res.StatusCode = 200; res.ContentType = "text/xml"; var xml = new XElement("xml"); if (result != null && result.Principal != null) { xml.Add(result.Principal.Claims.Select(claim => new XElement("claim", new XAttribute("type", claim.Type), new XAttribute("value", claim.Value)))); } if (result != null && result.Properties != null) { xml.Add(result.Properties.Select(extra => new XElement("extra", new XAttribute("type", extra.Key), new XAttribute("value", extra.Value)))); } using (var memory = new MemoryStream()) { using (var writer = new XmlTextWriter(memory, Encoding.UTF8)) { xml.WriteTo(writer); } res.Body.Write(memory.ToArray(), 0, memory.ToArray().Length); } }
private static string ReadBody(HttpResponse response) { response.Body.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(response.Body)) { return reader.ReadToEnd(); } }
protected override Task WriteFileAsync(HttpResponse response, CancellationToken cancellation) { WasWriteFileCalled = true; return Task.FromResult(0); }
public static async Task WriteJsonAsync(this HttpResponse response, string json) { response.ContentType = "application/json"; await response.WriteAsync(json); }
public static void SetNoCache(this HttpResponse response) { response.Headers.Add("Cache-Control", "no-store, no-cache, max-age=0"); response.Headers.Add("Pragma", "no-cache"); }
private static void Describe(HttpResponse res, ClaimsPrincipal principal) { res.StatusCode = 200; res.ContentType = "text/xml"; var xml = new XElement("xml"); if (principal != null) { foreach (var identity in principal.Identities) { xml.Add(identity.Claims.Select(claim => new XElement("claim", new XAttribute("type", claim.Type), new XAttribute("value", claim.Value)))); } } using (var memory = new MemoryStream()) { using (var writer = new XmlTextWriter(memory, Encoding.UTF8)) { xml.WriteTo(writer); } res.Body.Write(memory.ToArray(), 0, memory.ToArray().Length); } }
/// <summary> /// Writes the file to the response. /// </summary> /// <param name="response"> /// The <see cref="HttpResponse"/> where the file will be written /// </param> /// <param name="cancellation">The <see cref="CancellationToken"/>to cancel the operation.</param> /// <returns> /// A <see cref="Task"/> that will complete when the file has been written to the response. /// </returns> protected abstract Task WriteFileAsync(HttpResponse response, CancellationToken cancellation);
public HttpResponse(Microsoft.AspNet.Http.HttpResponse response) { _response = response; }