public override void Respond(IHttpContext context) { var src = context.Request.QueryString["from"]; if (string.IsNullOrEmpty(src)) { context.SetStatusToBadRequest(); return; } while (src.EndsWith("/")) src = src.Substring(0, src.Length - 1);// remove last /, because that has special meaning for Raven if (string.IsNullOrEmpty(src)) { context.SetStatusToBadRequest(); return; } using (ReplicationContext.Enter()) { var document = Database.Get(ReplicationConstants.RavenReplicationSourcesBasePath + "/" + src, null); if (document == null) { log.DebugFormat("Got replication last etag request from {0}: [{1}]", src, new SourceReplicationInformation()); context.WriteJson(new SourceReplicationInformation()); } else { var sourceReplicationInformation = document.DataAsJson.JsonDeserialization<SourceReplicationInformation>(); log.DebugFormat("Got replication last etag request from {0}: [{1}]", src, sourceReplicationInformation); context.WriteJson(sourceReplicationInformation); } } }
public override void Respond(IHttpContext context) { var match = urlMatcher.Match(context.GetRequestUrl()); var index = match.Groups[1].Value; switch (context.Request.HttpMethod) { case "HEAD": if(Database.IndexDefinitionStorage.IndexNames.Contains(index, StringComparer.InvariantCultureIgnoreCase) == false) context.SetStatusToNotFound(); break; case "GET": OnGet(context, index); break; case "PUT": Put(context, index); break; case "RESET": Database.ResetIndex(index); context.WriteJson(new {Reset = index}); break; case "DELETE": context.SetStatusToDeleted(); Database.DeleteIndex(index); break; } }
private void OnGet(IHttpContext context, string src) { using (Database.DisableAllTriggersForCurrentThread()) { var document = Database.Get(Constants.RavenReplicationSourcesBasePath + "/" + src, null); SourceReplicationInformation sourceReplicationInformation; Guid serverInstanceId = Database.TransactionalStorage.Id; // this is my id, sent to the remote serve if (document == null) { sourceReplicationInformation = new SourceReplicationInformation() { Source = src }; } else { sourceReplicationInformation = document.DataAsJson.JsonDeserialization<SourceReplicationInformation>(); sourceReplicationInformation.ServerInstanceId = serverInstanceId; } var currentEtag = context.Request.QueryString["currentEtag"]; log.Debug("Got replication last etag request from {0}: [Local: {1} Remote: {2}]", src, sourceReplicationInformation.LastDocumentEtag, currentEtag); context.WriteJson(sourceReplicationInformation); } }
public override void Respond(IHttpContext context) { var match = urlMatcher.Match(context.GetRequestUrl()); var index = match.Groups[1].Value; var indexQuery = context.GetIndexQueryFromHttpContext(Database.Configuration.MaxPageSize); var facetStart = context.GetFacetStartFromHttpContext(); var facetPageSize = context.GetFacetPageSizeFromHttpContext(); List<Facet> facets; Etag etag; if (TryGetFacets(context, index, out etag, out facets) == false) return; if (context.MatchEtag(etag)) { context.SetStatusToNotModified(); return; } context.WriteETag(etag); context.WriteJson(Database.ExecuteGetTermsQuery(index, indexQuery, facets, facetStart, facetPageSize)); }
public override void Respond(IHttpContext context) { BoundedMemoryTarget boundedMemoryTarget = null; if (LogManager.Configuration != null && LogManager.Configuration.AllTargets != null) { boundedMemoryTarget = LogManager.Configuration.AllTargets.OfType<BoundedMemoryTarget>().FirstOrDefault(); } if(boundedMemoryTarget == null) { context.SetStatusToNotFound(); context.WriteJson(new { Error = "HttpEndpoint was not registered in the log configuration, logs endpoint disable" }); return; } IEnumerable<LogEventInfo> log = boundedMemoryTarget.GeneralLog; switch (context.Request.QueryString["type"]) { case "error": case "warn": log = boundedMemoryTarget.WarnLog; break; } context.WriteJson(log.Select(x => new { x.TimeStamp, Message = x.FormattedMessage, x.LoggerName, Level = x.Level.Name, Exception = x.Exception == null ? null : x.Exception.ToString() })); }
public override void Respond(IHttpContext context) { Guid mostRecentDocumentEtag = Guid.Empty; Guid mostRecentAttachmentEtag = Guid.Empty; var replicationTask = Database.StartupTasks.OfType<ReplicationTask>().FirstOrDefault(); Database.TransactionalStorage.Batch(accessor => { mostRecentDocumentEtag = accessor.Staleness.GetMostRecentDocumentEtag(); mostRecentAttachmentEtag = accessor.Staleness.GetMostRecentAttachmentEtag(); }); context.WriteJson(RavenJObject.FromObject(new ReplicationStatistic { Self = Database.ServerUrl, MostRecentDocumentEtag = mostRecentDocumentEtag, MostRecentAttachmentEtag = mostRecentAttachmentEtag, Stats = replicationTask == null ? new List<ReplicationStats>() : replicationTask.ReplicationFailureStats.Select(pair => new ReplicationStats { Url = pair.Key, FailureCount = pair.Value.Count, TimeStamp = pair.Value.Timestamp, LastError = pair.Value.LastError }).ToList() })); }
public override void Respond(IHttpContext context) { var src = context.Request.QueryString["from"]; var dbid = context.Request.QueryString["dbid"]; if (dbid == Database.TransactionalStorage.Id.ToString()) throw new InvalidOperationException("Both source and target databases have database id = " + dbid + "\r\nDatabase cannot replicate to itself."); if (string.IsNullOrEmpty(src)) { context.SetStatusToBadRequest(); return; } while (src.EndsWith("/")) src = src.Substring(0, src.Length - 1);// remove last /, because that has special meaning for Raven if (string.IsNullOrEmpty(src)) { context.SetStatusToBadRequest(); return; } switch (context.Request.HttpMethod) { case "GET": OnGet(context, src); break; case "PUT": OnPut(context, src); break; } }
/// <summary> /// Invoke all modules /// </summary> /// <param name="context"></param> /// <returns><c>true</c> if no modules have aborted the handling. Any module throwing an exception is also considered to be abort.</returns> public void InvokeAsync(IHttpContext context, AsyncModuleHandler callback) { var canContinue = HandleBeginRequest(context); if (canContinue) canContinue = InvokeModules(context, _authenticationModules, InvokeAuthenticate); if (canContinue) canContinue = InvokeModules(context, _routingModules, InvokeRouting); if (canContinue) canContinue = InvokeModules(context, _authorizationModules, InvokeAuthorize); if (canContinue) { var modules = _workerModules.GetEnumerator(); if (modules.MoveNext()) { ((IWorkerModule)modules.Current).HandleRequestAsync(context, result => InvokeNextWorker(result, modules, innerResult => { HandleEndRequest(context); callback(innerResult); })); } else { callback(new AsyncModuleResult(context, ModuleResult.Continue)); } } else { HandleEndRequest(context); callback(new AsyncModuleResult(context, ModuleResult.Stop)); } }
public override List<string> GetApprovedDatabases(IHttpContext context) { var user = context.User as OAuthPrincipal; if(user == null) return new List<string>(); return user.GetApprovedDatabases(); }
private void Get(IHttpContext context, string docId) { context.Response.AddHeader("Content-Type", "application/json; charset=utf-8"); if (string.IsNullOrEmpty(context.Request.Headers["If-None-Match"])) { GetDocumentDirectly(context, docId); return; } Database.TransactionalStorage.Batch( _ => // we are running this here to ensure transactional safety for the two operations { var transactionInformation = GetRequestTransaction(context); var documentMetadata = Database.GetDocumentMetadata(docId, transactionInformation); if (documentMetadata == null) { context.SetStatusToNotFound(); return; } Debug.Assert(documentMetadata.Etag != null); if (context.MatchEtag(documentMetadata.Etag.Value)) { context.SetStatusToNotModified(); return; } if (documentMetadata.NonAuthoritiveInformation != null && documentMetadata.NonAuthoritiveInformation.Value) { context.SetStatusToNonAuthoritiveInformation(); } GetDocumentDirectly(context, docId); }); }
public override void Send(IHttpContext context) { context.StatusCode = httpStatusCode; Properties["message"] = message; Properties["errorId"] = errorId; base.Send(context); }
/// <summary> /// Initializes a new instance of the <see cref="ControllerContext"/> class. /// </summary> /// <param name="context">Request context.</param> public ControllerContext(IHttpContext context) { ViewData = new ViewData(); HttpContext = context; Uri = context.Request.Uri; UriRewrite = context.Request.Uri; }
public override void Respond(IHttpContext context) { var match = urlMatcher.Match(context.GetRequestUrl()); var docId = match.Groups[1].Value; switch (context.Request.HttpMethod) { case "GET": Get(context, docId); break; case "DELETE": Database.Delete(docId, context.GetEtag(), GetRequestTransaction(context)); context.SetStatusToDeleted(); break; case "PUT": Put(context, docId); break; case "PATCH": var patchRequestJson = context.ReadJsonArray(); var patchRequests = patchRequestJson.Cast<RavenJObject>().Select(PatchRequest.FromJson).ToArray(); var patchResult = Database.ApplyPatch(docId, context.GetEtag(), patchRequests, GetRequestTransaction(context)); switch (patchResult) { case PatchResult.DocumentDoesNotExists: context.SetStatusToNotFound(); break; case PatchResult.Patched: context.Response.AddHeader("Location", Database.Configuration.GetFullUrl("/docs/" + docId)); context.WriteJson(new {Patched = true}); break; default: throw new ArgumentOutOfRangeException("Value " + patchResult + " is not understood"); } break; } }
public override List<string> GetApprovedDatabases(IPrincipal user, IHttpContext context = null) { var oAuthUser = user as OAuthPrincipal; if (oAuthUser == null) return new List<string>(); return oAuthUser.GetApprovedDatabases(); }
public bool HandleRequest(IHttpContext context) { EnsureLogger(context.ServerInfo.LoggerFactory); var action = context.ServerInfo.ActionFactory.Create(actionType); var routeContext = new RouteContext(context, GetRouteData(context.Request.Url.AbsolutePath)); IActionResult actionResult = null; switch (context.Request.HttpMethod.ToUpper()) { case "GET": logger.Debug("Dispatching GET request to {0}", action); actionResult = action.Get(routeContext); break; case "POST": logger.Debug("Dispatching POST request to {0}", action); actionResult = action.Post(routeContext); break; } if (actionResult == null) { logger.Info("Action {0} did not handle the request", action); return false; } logger.Info("Request handled by action {0}, executing result...", action); actionResult.Execute(context); return true; }
public override bool Authorize(IHttpContext ctx) { if (server.DefaultConfiguration.AnonymousUserAccessMode == AnonymousUserAccessMode.None && IsInvalidUser(ctx)) { var requestUrl = ctx.GetRequestUrl(); if (NeverSecret.Urls.Contains(requestUrl, StringComparer.InvariantCultureIgnoreCase)) return true; ctx.SetStatusToUnauthorized(); return false; } var httpRequest = ctx.Request; if (server.DefaultConfiguration.AnonymousUserAccessMode == AnonymousUserAccessMode.Get && IsInvalidUser(ctx) && IsGetRequest(httpRequest.HttpMethod, httpRequest.Url.AbsolutePath) == false) { var requestUrl = ctx.GetRequestUrl(); if (NeverSecret.Urls.Contains(requestUrl, StringComparer.InvariantCultureIgnoreCase)) return true; ctx.SetStatusToUnauthorized(); return false; } if (IsInvalidUser(ctx) == false) CurrentOperationContext.Headers.Value[Constants.RavenAuthenticatedUser] = ctx.User.Identity.Name; return true; }
public override void Respond(IHttpContext context) { if (string.IsNullOrEmpty(context.Request.QueryString["no-op"]) == false) { // this is a no-op request which is there just to force the client HTTP layer to handle the authentication // only used for legacy clients return; } if("generate-single-use-auth-token".Equals(context.Request.QueryString["op"],StringComparison.InvariantCultureIgnoreCase)) { // using windows auth with anonymous access = none sometimes generate a 401 even though we made two requests // instead of relying on windows auth, which require request buffering, we generate a one time token and return it. // we KNOW that the user have access to this db for writing, since they got here, so there is no issue in generating // a single use token for them. var token = server.RequestAuthorizer.GenerateSingleUseAuthToken(Database, context.User); context.WriteJson(new { Token = token }); return; } if (HttpContext.Current != null) { HttpContext.Current.Server.ScriptTimeout = 60*60*6; // six hours should do it, I think. } var options = new BulkInsertOptions { CheckForUpdates = context.GetCheckForUpdates(), CheckReferencesInIndexes = context.GetCheckReferencesInIndexes() }; var operationId = ExtractOperationId(context); var sp = Stopwatch.StartNew(); var status = new BulkInsertStatus(); int documents = 0; var mre = new ManualResetEventSlim(false); var currentDatbase = Database; var task = Task.Factory.StartNew(() => { currentDatbase.BulkInsert(options, YieldBatches(context, mre, batchSize => documents += batchSize), operationId); status.Documents = documents; status.Completed = true; }); long id; Database.AddTask(task, status, out id); mre.Wait(Database.WorkContext.CancellationToken); context.Log(log => log.Debug("\tBulk inserted received {0:#,#;;0} documents in {1}, task #: {2}", documents, sp.Elapsed, id)); context.WriteJson(new { OperationId = id }); }
public override void Respond(IHttpContext context) { var auth = context.Request.Headers["Authorization"]; if(string.IsNullOrEmpty(auth)) { context.SetStatusToBadRequest(); context.WriteJson(new { Error = "Could not find authorization header" }); return; } if (auth.StartsWith("Bearer") == false) { context.SetStatusToBadRequest(); context.WriteJson(new { Error = "Authorization header does not starts with Bearer" }); return; } context.Response.SetCookie("OAuth-Token", Uri.EscapeDataString(auth)); }
public override void RespondToAdmin(IHttpContext context) { if (EnsureSystemDatabase(context) == false) return; var restoreRequest = context.ReadJsonObject<RestoreRequest>(); var ravenConfiguration = new RavenConfiguration(); if (File.Exists(Path.Combine(restoreRequest.RestoreLocation, "Raven.ravendb"))) { ravenConfiguration.DefaultStorageTypeName = "Raven.Storage.Managed.TransactionalStorage, Raven.Storage.Managed"; } else if (Directory.Exists(Path.Combine(restoreRequest.RestoreLocation, "new"))) { ravenConfiguration.DefaultStorageTypeName = "Raven.Storage.Esent.TransactionalStorage, Raven.Storage.Esent"; } var restoreDoc = new List<string>(); // Commented out unfinished code to get it to compile // DocumentDatabase.Restore(ravenConfiguration, restoreRequest.RestoreLocation, restoreRequest.DatabaseLocation, // msg => // { // // }); // SystemDatabase. }
/// <summary> /// Responds the specified context. /// </summary> /// <param name="context">The context.</param> public override void Respond(IHttpContext context) { var match = urlMatcher.Match(context.GetRequestUrl()); var index = match.Groups[1].Value; var term = context.Request.QueryString["term"]; var field = context.Request.QueryString["field"]; StringDistanceTypes distanceTypes; int numOfSuggestions; float accuracy; if (Enum.TryParse(context.Request.QueryString["distance"], true, out distanceTypes) == false) distanceTypes =StringDistanceTypes.Default; if (int.TryParse(context.Request.QueryString["max"], out numOfSuggestions) == false) numOfSuggestions = 10; if(float.TryParse(context.Request.QueryString["accuracy"], out accuracy) == false) accuracy = 0.5f; var query = new SuggestionQuery { Distance = distanceTypes, Field = field, MaxSuggestions = numOfSuggestions, Term = term, Accuracy = accuracy }; var suggestionQueryResult = Database.ExecuteSuggestionQuery(index, query); context.WriteJson(suggestionQueryResult); }
public override void Respond(IHttpContext context) { var array = Database.GetAttachments(context.GetStart(), context.GetPageSize(Database.Configuration.MaxPageSize), context.GetEtagFromQueryString()); context.WriteJson(array); }
public ModuleResult HandleRequest(IHttpContext context) { if (OnListenerNotify != null) OnListenerNotify(null, new ListenerNotifyEventArgs() { Context = context }); return ModuleResult.Stop; }
public override void Respond(IHttpContext context) { var match = urlMatcher.Match(context.GetRequestUrl()); var filename = match.Groups[1].Value; var etag = context.GetEtag(); switch (context.Request.HttpMethod) { case "GET": var attachmentAndHeaders = Database.GetStatic(filename); if (attachmentAndHeaders == null) { context.SetStatusToNotFound(); return; } if (context.MatchEtag(attachmentAndHeaders.Etag)) { context.SetStatusToNotModified(); return; } context.WriteData(attachmentAndHeaders.Data, attachmentAndHeaders.Metadata, attachmentAndHeaders.Etag); break; case "PUT": Database.PutStatic(filename, context.GetEtag(), context.Request.InputStream.ReadData(), context.Request.Headers.FilterHeaders(isServerDocument:false)); context.SetStatusToCreated("/static/" + filename); break; case "DELETE": Database.DeleteStatic(filename, etag); context.SetStatusToDeleted(); break; } }
public override void Respond(IHttpContext context) { var match = urlMatcher.Match(context.GetRequestUrl()); var docId = Uri.UnescapeDataString(match.Groups[1].Value); switch (context.Request.HttpMethod) { case "HEAD": Head(context, docId); break; case "GET": Get(context, docId); break; case "DELETE": Database.Delete(docId, context.GetEtag(), GetRequestTransaction(context)); context.SetStatusToDeleted(); break; case "PUT": Put(context, docId); break; case "PATCH": var patchRequestJson = context.ReadJsonArray(); var patchRequests = patchRequestJson.Cast<RavenJObject>().Select(PatchRequest.FromJson).ToArray(); var patchResult = Database.ApplyPatch(docId, context.GetEtag(), patchRequests, GetRequestTransaction(context)); ProcessPatchResult(context, docId, patchResult.PatchResult, null); break; case "EVAL": var advPatchRequestJson = context.ReadJsonObject<RavenJObject>(); var advPatch = ScriptedPatchRequest.FromJson(advPatchRequestJson); var advPatchResult = Database.ApplyPatch(docId, context.GetEtag(), advPatch, GetRequestTransaction(context), true); ProcessPatchResult(context, docId, advPatchResult.Item1.PatchResult, advPatchResult.Item2); break; } }
public override void Respond(IHttpContext context) { JArray itemsToLoad; if(context.Request.HttpMethod == "POST") itemsToLoad = context.ReadJsonArray(); else itemsToLoad = new JArray(context.Request.QueryString.GetValues("id")); var result = new MultiLoadResult(); var loadedIds = new HashSet<string>(); var includes = context.Request.QueryString.GetValues("include") ?? new string[0]; var transactionInformation = GetRequestTransaction(context); Database.TransactionalStorage.Batch(actions => { var addIncludesCommand = new AddIncludesCommand(Database, transactionInformation, result.Includes.Add, includes, loadedIds); foreach (JToken item in itemsToLoad) { var value = item.Value<string>(); if(loadedIds.Add(value)==false) continue; var documentByKey = actions.Documents.DocumentByKey(value, transactionInformation); if (documentByKey == null) continue; result.Results.Add(documentByKey.ToJson()); addIncludesCommand.Execute(documentByKey.DataAsJson); } }); context.WriteJson(result); }
public SessionStateContext(IHttpContext httpContext) { _httpContext = httpContext; SessionId = _httpContext.RequestCookies[AspNetSessionCookieName]; MetabasePath = (string)_httpContext.ServerVariables[MetadataPathServerVariable]; VirtualDirectoryPath = (string)_httpContext.ServerVariables[VirtualDirectoryPathServerVariable]; }
private Action AdaptHttpContext(IHttpContext httpContext, ServerLog serverLog) { if (pathsToFilter.Contains(httpContext.Request.Url.AbsolutePath)) return null; if (ignoreHilo && httpContext.Request.Url.AbsolutePath.StartsWith("/docs/Raven/Hilo/")) return null; if (httpContext.Request.Headers["Raven-Timer-Request"] != null) return null; var requestStream = new MemoryStream(); httpContext.SetRequestFilter(stream => { stream.CopyTo(requestStream); return new MemoryStream(requestStream.ToArray()); }); var responseStream = new MemoryStream(); httpContext.SetResponseFilter(stream => new MultiStreamWriter(responseStream, stream)); var trackedRequest = new TrackedRequest { Method = httpContext.Request.HttpMethod, Url = httpContext.Request.RawUrl, RequestHeaders = new NameValueCollection(httpContext.Request.Headers), RequestContent = requestStream, ResponseContent = responseStream, ResponseHeaders = httpContext.Response.GetHeaders(), }; return () => { trackedRequest.Status = httpContext.Response.StatusCode; serverLog.AddRequest(trackedRequest); }; }
public override void RespondToAdmin(IHttpContext context) { var docEtagStr = context.Request.QueryString["docEtag"]; Guid docEtag; var attachmentEtagStr = context.Request.QueryString["attachmentEtag"]; Guid attachmentEtag; if (Guid.TryParse(docEtagStr, out docEtag) == false & // intentionally so, we want to eval both sides Guid.TryParse(attachmentEtagStr, out attachmentEtag) == false) { context.SetStatusToBadRequest(); context.WriteJson(new { Error = "The query string variable 'docEtag' or 'attachmentEtag' must be set to a valid guid" }); return; } Database.TransactionalStorage.Batch(accessor => { if(docEtag != Guid.Empty) { accessor.Lists.RemoveAllBefore(Constants.RavenReplicationDocsTombstones, docEtag); } if(attachmentEtag != Guid.Empty) { accessor.Lists.RemoveAllBefore(Constants.RavenReplicationAttachmentsTombstones, attachmentEtag); } }); }
public bool Authorize(IHttpContext context) { var requestUrl = context.GetRequestUrl(); if (NeverSecret.Urls.Contains(requestUrl)) return true; //CORS pre-flight (ignore creds if using cors). if (!String.IsNullOrEmpty(Settings.AccessControlAllowOrigin) && context.Request.HttpMethod == "OPTIONS") { return true; } var oneTimeToken = context.Request.Headers["Single-Use-Auth-Token"]; if (string.IsNullOrEmpty(oneTimeToken) == false) { return AuthorizeUsingleUseAuthToken(context, oneTimeToken); } var authHeader = context.Request.Headers["Authorization"]; var hasApiKey = "True".Equals(context.Request.Headers["Has-Api-Key"], StringComparison.CurrentCultureIgnoreCase); var hasOAuthTokenInCookie = context.Request.HasCookie("OAuth-Token"); if (hasApiKey || hasOAuthTokenInCookie || string.IsNullOrEmpty(authHeader) == false && authHeader.StartsWith("Bearer ")) { return oAuthRequestAuthorizer.Authorize(context, hasApiKey, IgnoreDb.Urls.Contains(requestUrl)); } return windowsRequestAuthorizer.Authorize(context, IgnoreDb.Urls.Contains(requestUrl)); }
private ActionResult CheckFileSystem(IHttpContext context) { string path = _webUIPath + (context.Request.Url.AbsolutePath == "/" ? "/index.html" : context.Request.Url.AbsolutePath); if (_fileSystem.FileExists(path)) { string contentType = "text/html"; switch (Path.GetExtension(path)) { case ".css": contentType = "text/css"; break; case ".js": contentType = "text/javascript"; break; case ".png": contentType = "image/png"; break; case ".gif": contentType = "image/gif"; break; } return new ContentResult { Content = _fileSystem.ReadAllBytes(path), ContentType = contentType }; } return null; }
public IHttpContext EvalPostConnectDown(IHttpContext context) { PostConnectDown(context); return(context); }
public IHttpContext MethodTakesTwoArgs(IHttpContext context, int y) { return(context); }
public void DoesNotReturnContext(IHttpContext context) { /* This method intentionally left blank */ }
protected void OnDispatchingRequest(IHttpContext ctx) { ctx.Response.AddHeader("Raven-Server-Build", DocumentDatabase.BuildVersion); }
private bool DispatchRequest(IHttpContext ctx) { SetupRequestToProperDatabase(ctx); CurrentOperationContext.Headers.Value = new NameValueCollection(ctx.Request.Headers); CurrentOperationContext.Headers.Value[Constants.RavenAuthenticatedUser] = ""; CurrentOperationContext.User.Value = null; if (ctx.RequiresAuthentication && requestAuthorizer.Authorize(ctx) == false) { return(false); } try { OnDispatchingRequest(ctx); if (DefaultConfiguration.HttpCompression) { AddHttpCompressionIfClientCanAcceptIt(ctx); } // Cross-Origin Resource Sharing (CORS) is documented here: http://www.w3.org/TR/cors/ AddAccessControlHeaders(ctx); if (ctx.Request.HttpMethod == "OPTIONS") { return(false); } foreach (var requestResponderLazy in RequestResponders) { var requestResponder = requestResponderLazy.Value; if (requestResponder.WillRespond(ctx)) { requestResponder.Respond(ctx); return(requestResponder.IsUserInterfaceRequest); } } ctx.SetStatusToBadRequest(); if (ctx.Request.HttpMethod == "HEAD") { return(false); } ctx.Write( @" <html> <body> <h1>Could not figure out what to do</h1> <p>Your request didn't match anything that Raven knows to do, sorry...</p> </body> </html> "); } finally { try { CurrentOperationContext.Headers.Value = new NameValueCollection(); CurrentOperationContext.User.Value = null; currentDatabase.Value = DefaultResourceStore; currentConfiguration.Value = DefaultConfiguration; } catch { // this can happen during system shutdown } } return(false); }
public IHttpContext EvalPostPublishDown(IHttpContext context) { PostPublishDown(context); return(context); }
public IHttpContext EvalPostDisconnect(IHttpContext context) { PostDisconnect(context); return(context); }
public IHttpContext EvalGetDirectory(IHttpContext context) { GetDirectory(context); return(context); }
public TestHttpResponse(IHttpContext httpContext) { this.Context = httpContext; }
public IHttpContext GetAASX2(IHttpContext context) { GetAasx(context); return(context); }
public override void Respond(IHttpContext context) { RavenJArray itemsToLoad; if (context.Request.HttpMethod == "POST") { itemsToLoad = context.ReadJsonArray(); } else { itemsToLoad = new RavenJArray(context.Request.QueryString.GetValues("id")); } var result = new MultiLoadResult(); var loadedIds = new HashSet <string>(); var includes = context.Request.QueryString.GetValues("include") ?? new string[0]; var transactionInformation = GetRequestTransaction(context); var includedEtags = new List <byte>(); Database.TransactionalStorage.Batch(actions => { var addIncludesCommand = new AddIncludesCommand(Database, transactionInformation, (etag, includedDoc) => { includedEtags.AddRange(etag.ToByteArray()); result.Includes.Add(includedDoc); }, includes, loadedIds); foreach (RavenJToken item in itemsToLoad) { var value = item.Value <string>(); if (loadedIds.Add(value) == false) { continue; } var documentByKey = Database.Get(value, transactionInformation); if (documentByKey == null) { continue; } result.Results.Add(documentByKey.ToJson()); if (documentByKey.Etag != null) { includedEtags.AddRange(documentByKey.Etag.Value.ToByteArray()); } includedEtags.Add((documentByKey.NonAuthoritativeInformation ?? false) ? (byte)0 : (byte)1); addIncludesCommand.Execute(documentByKey.DataAsJson); } }); Guid computedEtag; using (var md5 = MD5.Create()) { var computeHash = md5.ComputeHash(includedEtags.ToArray()); computedEtag = new Guid(computeHash); } if (context.MatchEtag(computedEtag)) { context.SetStatusToNotModified(); return; } context.Response.AddHeader("ETag", computedEtag.ToString()); context.WriteJson(result); }
public override void ExecuteResponse(IHttpContext Context) { base.ExecuteResponse(Context); }
public GetSettingsController(IHttpContext context) : base(context) { }
public override void Respond(IHttpContext context) { var principal = context.User; if (principal == null || principal.Identity == null || principal.Identity.IsAuthenticated == false) { context.WriteJson(new { Remark = "Using anonymous user", AnonymousAreAdmins = server.SystemConfiguration.AnonymousUserAccessMode == AnonymousUserAccessMode.Admin }); return; } var windowsPrincipal = principal as WindowsPrincipal; if (windowsPrincipal != null) { context.WriteJson(new { Remark = "Using windows auth", User = windowsPrincipal.Identity.Name, IsAdmin = windowsPrincipal.IsAdministrator(server.SystemConfiguration.AnonymousUserAccessMode) }); return; } var principalWithDatabaseAccess = principal as PrincipalWithDatabaseAccess; if (principalWithDatabaseAccess != null) { context.WriteJson(new { Remark = "Using windows auth", User = principalWithDatabaseAccess.Identity.Name, IsAdminGlobal = principalWithDatabaseAccess.IsAdministrator(server.SystemConfiguration.AnonymousUserAccessMode), IsAdminCurrentDb = principalWithDatabaseAccess.IsAdministrator(Database), Databases = principalWithDatabaseAccess.AdminDatabases.Concat(principalWithDatabaseAccess.ReadOnlyDatabases).Concat(principalWithDatabaseAccess.ReadWriteDatabases) .Select(db => new { Database = db, IsAdmin = principal.IsAdministrator(db) }), principalWithDatabaseAccess.AdminDatabases, principalWithDatabaseAccess.ReadOnlyDatabases, principalWithDatabaseAccess.ReadWriteDatabases }); return; } var oAuthPrincipal = principal as OAuthPrincipal; if (oAuthPrincipal != null) { context.WriteJson(new { Remark = "Using OAuth", User = oAuthPrincipal.Name, IsAdminGlobal = oAuthPrincipal.IsAdministrator(server.SystemConfiguration.AnonymousUserAccessMode), IsAdminCurrentDb = oAuthPrincipal.IsAdministrator(Database), Databases = oAuthPrincipal.TokenBody.AuthorizedDatabases .Select(db => new { Database = db.TenantId, IsAdmin = principal.IsAdministrator(db.TenantId) }), oAuthPrincipal.TokenBody, }); return; } context.WriteJson(new { Remark = "Unknown auth", Principal = principal }); }
public TodayYestDataController(IHttpContext context) : base(context) { }
public ReportsController(IHttpContext context) : base(context) { }
public GraphDataController(IHttpContext context) : base(context) { }
public ExtraDataController(IHttpContext context) : base(context) { }
public EditControllerPost(IHttpContext context) : base(context) { }
public RecordsController(IHttpContext context) : base(context) { }
/// <summary> /// Force an expiration of the session /// </summary> /// <param name="self">The context to find the session in</param> /// <returns>An awaitable task</returns> public static Task ExpireSession(this IHttpContext self) => ExpireSession(self.Request.SessionID);
public TagController(IHttpContext context) : base(context) { }
/// <summary> /// Gets the session values for the request, or null if no session exists. /// This method assumes that the SessionID value of the requests has been set /// </summary> /// <param name="self">The context to get the session values for</param> /// <returns>The values for the session, or null</returns> public static Dictionary <string, object> CurrentSession(this IHttpContext self) => CurrentSession(self.Request.SessionID);
public IHttpContext Response(IHttpContext context) { context.Response.SendResponse(Shared.Resources.GetBytes("Resources.Icons.jarvis.ico")); return(context); }
/// <summary> /// 读取Header /// </summary> public static string GetHeader(this IHttpContext context, string key) { return(context.Request.Header[key]); }
/// <summary> /// Gets or creates a session for the current context /// </summary> /// <param name="self">The context to use</param> /// <returns>The values for the session</returns> public static Task <Dictionary <string, object> > GetOrCreateSessionAsync(this IHttpContext self, TimeSpan duration = default(TimeSpan), SessionCreateCallback createCallback = null, SessionExpireCallback expireCallback = null) => GetOrCreateSessionAsync(self.Request.SessionID, duration, self.Request, createCallback, expireCallback);
private bool ShouldReturnJsonResponse(IHttpContext context) => context.Request.Headers[HostingConstants.DotvvmFileUploadAsyncHeaderName] == "true" || context.Request.Query["returnJson"] == "true";
/// <summary> /// Updates the timeout-duration for a session. /// If the session does not exist, this method does nothing. /// </summary> /// <param name="self">The session to update</param> /// <param name="duration">The new duration</param> public static void SetSessionDuration(this IHttpContext self, TimeSpan duration) => SetSessionDuration(self.Request.SessionID, duration);
/// <summary> /// <para>Called when at least one route is matched for the requested URL path, /// but none of them is associated with the HTTP method of the request.</para> /// <para>The default behavior is to send an empty <c>405 Method Not Allowed</c> response.</para> /// </summary> /// <param name="context">The context of the request being handled.</param> /// <returns>A <see cref="Task"/> representing the ongoing operation.</returns> protected virtual Task OnMethodNotAllowedAsync(IHttpContext context) => throw HttpException.MethodNotAllowed();
/// <summary> /// 设置Header /// </summary> public static void SetHeader(this IHttpContext context, string key, string value) { context.Response.Header[key] = value; }