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;
}
