private async Task IndexEntries(QueryOperationContext queryContext, OperationCancelToken token, RequestTimeTracker tracker, HttpMethod method, bool ignoreLimit)
{
var indexQuery = await GetIndexQuery(queryContext.Documents, method, tracker);
var existingResultEtag = GetLongFromHeaders("If-None-Match");
var result = await Database.QueryRunner.ExecuteIndexEntriesQuery(indexQuery, queryContext, ignoreLimit, existingResultEtag, token);
if (result.NotModified)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.NotModified;
return;
}
HttpContext.Response.Headers[Constants.Headers.Etag] = CharExtensions.ToInvariantString(result.ResultEtag);
await using (var writer = new AsyncBlittableJsonTextWriter(queryContext.Documents, ResponseBodyStream()))
{
await writer.WriteIndexEntriesQueryResultAsync(queryContext.Documents, result, token.Token);
}
}
public async Task Exists()
{
var hash = GetStringQueryString("hash");
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
using (context.OpenReadTransaction())
using (Slice.From(context.Allocator, hash, out var hashSlice))
{
var count = AttachmentsStorage.GetCountOfAttachmentsForHash(context, hashSlice);
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
writer.WriteStartObject();
writer.WritePropertyName("Hash");
writer.WriteString(hash);
writer.WriteComma();
writer.WritePropertyName("Count");
writer.WriteInteger(count);
writer.WriteEndObject();
}
}
}
public override HttpRequestMessage CreateRequest(JsonOperationContext ctx, ServerNode node, out string url)
{
url = $"{node.Url}/admin/certificates/replace-cluster-cert?replaceImmediately={_replaceImmediately}";
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
Content = new BlittableJsonContent(async stream =>
{
await using (var writer = new AsyncBlittableJsonTextWriter(ctx, stream))
{
writer.WriteStartObject();
writer.WritePropertyName(nameof(CertificateDefinition.Certificate));
writer.WriteString(Convert.ToBase64String(_certBytes)); // keep the private key -> this is a server cert
writer.WriteEndObject();
}
})
};
return(request);
}
public async Task ListRemoteConnections()
{
using (ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context))
await using (var write = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
context.Write(write,
new DynamicJsonValue
{
["Remote-Connections"] = new DynamicJsonArray(RemoteConnection.RemoteConnectionsList
.Select(connection => new DynamicJsonValue
{
[nameof(RemoteConnection.RemoteConnectionInfo.Caller)] = connection.Caller,
[nameof(RemoteConnection.RemoteConnectionInfo.Term)] = connection.Term,
[nameof(RemoteConnection.RemoteConnectionInfo.Destination)] = connection.Destination,
[nameof(RemoteConnection.RemoteConnectionInfo.StartAt)] = connection.StartAt,
["Duration"] = DateTime.UtcNow - connection.StartAt,
[nameof(RemoteConnection.RemoteConnectionInfo.Number)] = connection.Number,
}))
});
}
}
private async Task Explain(DocumentsOperationContext context, RequestTimeTracker tracker, HttpMethod method)
{
var indexQuery = await GetIndexQuery(context, method, tracker);
var explanations = Database.QueryRunner.ExplainDynamicIndexSelection(indexQuery, out string indexName);
using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream(), Database.DatabaseShutdown))
{
writer.WriteStartObject();
writer.WritePropertyName("IndexName");
writer.WriteString(indexName);
writer.WriteComma();
writer.WriteArray(context, "Results", explanations, (w, c, explanation) =>
{
w.WriteExplanation(context, explanation);
});
writer.WriteEndObject();
await writer.OuterFlushAsync();
}
}
public async Task GetConfiguration()
{
using (ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context))
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
var djv = new DynamicJsonValue
{
[nameof(GetLogsConfigurationResult.CurrentMode)] = LoggingSource.Instance.LogMode,
[nameof(GetLogsConfigurationResult.Mode)] = ServerStore.Configuration.Logs.Mode,
[nameof(GetLogsConfigurationResult.Path)] = ServerStore.Configuration.Logs.Path.FullPath,
[nameof(GetLogsConfigurationResult.UseUtcTime)] = ServerStore.Configuration.Logs.UseUtcTime,
[nameof(GetLogsConfigurationResult.RetentionTime)] = LoggingSource.Instance.RetentionTime,
[nameof(GetLogsConfigurationResult.RetentionSize)] = LoggingSource.Instance.RetentionSize == long.MaxValue ? null : (object)LoggingSource.Instance.RetentionSize,
[nameof(GetLogsConfigurationResult.Compress)] = LoggingSource.Instance.Compressing
};
var json = context.ReadObject(djv, "logs/configuration");
writer.WriteObject(json);
}
}
private async Task GetTaskConfigurationsAsync <T>(OngoingTaskType type, Func <BlittableJsonReaderObject, T> converter)
where T : IDynamicJsonValueConvertible
{
var taskName = GetStringQueryString("name", required: false);
using (ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (context.OpenReadTransaction())
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
var blittables = ServerStore.Cluster.GetServerWideConfigurations(context, type, taskName);
var result = new ServerWideTasksResult <T>();
foreach (var blittable in blittables)
{
var configuration = converter(blittable);
result.Results.Add(configuration);
}
context.Write(writer, result.ToJson());
}
}
public async Task GetStudioConfiguration()
{
var configuration = Database.StudioConfiguration;
if (configuration == null)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
using (ContextPool.AllocateOperationContext(out JsonOperationContext context))
{
var val = configuration.ToJson();
var clientConfigurationJson = context.ReadObject(val, Constants.Configuration.StudioId);
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
writer.WriteObject(clientConfigurationJson);
}
}
}
private void WriteHeaders(AsyncBlittableJsonTextWriter writer, HttpContext httpContext, LazyStringValue headersProperty)
{
writer.WritePropertyName(headersProperty);
writer.WriteStartObject();
bool headerStart = true;
foreach (var header in httpContext.Response.Headers)
{
foreach (var value in header.Value)
{
if (headerStart == false)
{
writer.WriteComma();
}
headerStart = false;
writer.WritePropertyName(header.Key);
writer.WriteString(value);
}
}
writer.WriteEndObject();
}
public async Task Allocations()
{
var delay = GetIntValueQueryString("delay", required: false) ?? 5;
IReadOnlyCollection <AllocationInfo> allocations;
using (var listener = new Expensive_GcEventListener())
{
await Task.Delay(TimeSpan.FromSeconds(delay));
allocations = listener.Allocations;
}
using (ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
writer.WriteStartObject();
var first = true;
foreach (var alloc in allocations.OrderByDescending(x => x.Allocations))
{
if (first == false)
{
writer.WriteComma();
}
first = false;
writer.WritePropertyName(alloc.Type);
writer.WriteStartObject();
writer.WritePropertyName("Memory");
writer.WriteString(new Size((long)alloc.Allocations, SizeUnit.Bytes).ToString());
writer.WriteComma();
writer.WritePropertyName("Allocations");
writer.WriteInteger(alloc.NumberOfAllocations);
writer.WriteEndObject();
}
writer.WriteEndObject();
}
}
public static async Task SendDatabaseRecord(string name, ServerStore serverStore, HttpContext httpContext, Stream responseBodyStream)
{
using (serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
{
var dbId = Constants.Documents.Prefix + name;
using (context.OpenReadTransaction())
using (var dbDoc = serverStore.Cluster.Read(context, dbId, out long etag))
{
if (dbDoc == null)
{
httpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
httpContext.Response.Headers["Database-Missing"] = name;
await using (var writer = new AsyncBlittableJsonTextWriter(context, responseBodyStream))
{
context.Write(writer,
new DynamicJsonValue
{
["Type"] = "Error",
["Message"] = "Database " + name + " wasn't found"
});
}
return;
}
await using (var writer = new AsyncBlittableJsonTextWriter(context, responseBodyStream))
{
writer.WriteStartObject();
writer.WriteDocumentPropertiesWithoutMetadata(context, new Document
{
Data = dbDoc
});
writer.WriteComma();
writer.WritePropertyName("Etag");
writer.WriteInteger(etag);
writer.WriteEndObject();
}
}
}
}
public static async Task TrySavingAsync(string topologyHash, ClusterTopologyResponse clusterTopology, DocumentConventions conventions, JsonOperationContext context, CancellationToken token)
{
try
{
if (conventions.DisableTopologyCache)
{
return;
}
var path = GetPath(topologyHash, conventions);
if (clusterTopology == null)
{
Clear(path);
return;
}
using (var stream = SafeFileStream.Create(path, FileMode.Create, FileAccess.Write, FileShare.Read))
await using (var writer = new AsyncBlittableJsonTextWriter(context, stream))
{
var json = new DynamicJsonValue
{
[nameof(clusterTopology.Topology)] = clusterTopology.Topology.ToJson(),
[nameof(clusterTopology.Leader)] = clusterTopology.Leader,
[nameof(clusterTopology.NodeTag)] = clusterTopology.NodeTag,
[nameof(clusterTopology.Etag)] = clusterTopology.Etag,
["PersistedAt"] = DateTimeOffset.UtcNow.ToString(DefaultFormat.DateTimeOffsetFormatsToWrite),
};
context.Write(writer, json);
await writer.FlushAsync(token).ConfigureAwait(false);
}
}
catch (Exception e)
{
if (_logger.IsInfoEnabled)
{
_logger.Info("Could not persist the cluster topology", e);
}
}
}
public override HttpRequestMessage CreateRequest(JsonOperationContext ctx, ServerNode node, out string url)
{
var path = new StringBuilder(node.Url)
.Append("/databases/")
.Append(node.Database)
.Append("/queries")
.Append("?allowStale=")
.Append(_options.AllowStale)
.Append("&maxOpsPerSec=")
.Append(_options.MaxOpsPerSecond)
.Append("&details=")
.Append(_options.RetrieveDetails);
if (_options.StaleTimeout != null)
{
path
.Append("&staleTimeout=")
.Append(_options.StaleTimeout.Value);
}
var request = new HttpRequestMessage
{
Method = HttpMethods.Patch,
Content = new BlittableJsonContent(async stream =>
{
await using (var writer = new AsyncBlittableJsonTextWriter(ctx, stream))
{
writer.WriteStartObject();
writer.WritePropertyName("Query");
writer.WriteIndexQuery(_conventions, ctx, _queryToUpdate);
writer.WriteEndObject();
}
})
};
url = path.ToString();
return(request);
}
private static async Task WriteForDatabase(ZipArchive archive, JsonOperationContext context, LocalEndpointClient localEndpointClient, string databaseName, string path = null, CancellationToken token = default)
{
token.ThrowIfCancellationRequested();
var endpointParameters = new Dictionary <string, Microsoft.Extensions.Primitives.StringValues>
{
{ "database", new Microsoft.Extensions.Primitives.StringValues(databaseName) }
};
foreach (var route in DebugInfoPackageUtils.Routes.Where(x => x.TypeOfRoute == RouteInformation.RouteType.Databases))
{
token.ThrowIfCancellationRequested();
try
{
var entry = archive.CreateEntry(DebugInfoPackageUtils.GetOutputPathFromRouteInformation(route, path ?? databaseName));
entry.ExternalAttributes = ((int)(FilePermissions.S_IRUSR | FilePermissions.S_IWUSR)) << 16;
await using (var entryStream = entry.Open())
await using (var writer = new AsyncBlittableJsonTextWriter(context, entryStream))
{
using (var endpointOutput = await localEndpointClient.InvokeAndReadObjectAsync(route, context, endpointParameters))
{
context.Write(writer, endpointOutput);
await writer.FlushAsync();
await entryStream.FlushAsync(token);
}
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception e)
{
await DebugInfoPackageUtils.WriteExceptionAsZipEntryAsync(e, archive, path ?? databaseName);
}
}
}
public Task RunningQueries()
{
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream(), Database.DatabaseShutdown))
{
writer.WriteStartObject();
var isFirst = true;
foreach (var group in Database.QueryRunner.CurrentlyRunningQueries.GroupBy(x => x.IndexName))
{
if (isFirst == false)
{
writer.WriteComma();
}
isFirst = false;
writer.WritePropertyName(group.Key);
writer.WriteStartArray();
var isFirstInternal = true;
foreach (var query in group)
{
if (isFirstInternal == false)
{
writer.WriteComma();
}
isFirstInternal = false;
query.Write(writer, context);
}
writer.WriteEndArray();
}
writer.WriteEndObject();
}
return(Task.CompletedTask);
}
private async Task GetConflictsByEtag(long etag)
{
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
using (context.OpenReadTransaction())
{
var skip = GetStart();
var pageSize = GetPageSize();
var alreadyAdded = new HashSet <LazyStringValue>(LazyStringValueComparer.Instance);
var array = new DynamicJsonArray();
var conflicts = Database.DocumentsStorage.ConflictsStorage.GetConflictsAfter(context, etag);
foreach (var conflict in conflicts)
{
if (alreadyAdded.Add(conflict.Id))
{
if (skip > 0)
{
skip--;
continue;
}
if (pageSize-- <= 0)
{
break;
}
array.Add(new DynamicJsonValue
{
[nameof(GetConflictsResult.Id)] = conflict.Id,
[nameof(GetConflictsResult.Conflict.LastModified)] = conflict.LastModified
});
}
}
context.Write(writer, new DynamicJsonValue
{
["TotalResults"] = Database.DocumentsStorage.ConflictsStorage.GetNumberOfDocumentsConflicts(context),
[nameof(GetConflictsResult.Results)] = array
});
}
}
private async Task ExecuteQueryOperation(IndexQueryServerSide query,
Func <QueryRunner,
QueryOperationOptions,
Action <IOperationProgress>, OperationCancelToken,
Task <IOperationResult> > operation,
IDisposable returnContextToPool,
Operations.Operations.OperationType operationType)
{
var options = GetQueryOperationOptions();
var token = CreateTimeLimitedQueryOperationToken();
var operationId = Database.Operations.GetNextOperationId();
var indexName = query.Metadata.IsDynamic
? (query.Metadata.IsCollectionQuery ? "collection/" : "dynamic/") + query.Metadata.CollectionName
: query.Metadata.IndexName;
var details = new BulkOperationResult.OperationDetails
{
Query = query.Query
};
var task = Database.Operations.AddOperation(
Database,
indexName,
operationType,
onProgress => operation(Database.QueryRunner, options, onProgress, token), operationId, details, token);
using (ContextPool.AllocateOperationContext(out JsonOperationContext context))
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
writer.WriteOperationIdAndNodeTag(context, operationId, ServerStore.NodeTag);
}
_ = task.ContinueWith(_ =>
{
using (returnContextToPool)
token.Dispose();
});
}
public async Task NextIdentityFor()
{
var name = GetQueryStringValueAndAssertIfSingleAndNotEmpty("name");
if (name[name.Length - 1] != '|')
{
name += '|';
}
var(_, _, newIdentityValue) = await Database.ServerStore.GenerateClusterIdentityAsync(name, Database.IdentityPartsSeparator, Database.Name, GetRaftRequestIdFromQuery());
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
writer.WriteStartObject();
writer.WritePropertyName("NewIdentityValue");
writer.WriteInteger(newIdentityValue);
writer.WriteEndObject();
}
}
public async Task GetTestSqlConnection()
{
try
{
var factoryName = GetStringQueryString("factoryName");
var connectionString = await new StreamReader(HttpContext.Request.Body).ReadToEndAsync();
RelationalDatabaseWriter.TestConnection(factoryName, connectionString);
DynamicJsonValue result = new DynamicJsonValue
{
[nameof(NodeConnectionTestResult.Success)] = true,
};
using (ContextPool.AllocateOperationContext(out JsonOperationContext context))
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
context.Write(writer, result);
}
}
catch (Exception ex)
{
if (Logger.IsInfoEnabled)
{
Logger.Info("Error occurred during sql replication connection test", ex);
}
using (ContextPool.AllocateOperationContext(out JsonOperationContext context))
{
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
context.Write(writer, new DynamicJsonValue
{
[nameof(NodeConnectionTestResult.Success)] = false,
[nameof(NodeConnectionTestResult.Error)] = ex.ToString()
});
}
}
}
}
private static void WriteAttachmentDetails(AsyncBlittableJsonTextWriter writer, Attachment attachment, string documentId)
{
writer.WriteStartObject();
writer.WritePropertyName(nameof(AttachmentDetails.Name));
writer.WriteString(attachment.Name);
writer.WriteComma();
writer.WritePropertyName(nameof(AttachmentDetails.Hash));
writer.WriteString(attachment.Base64Hash.ToString());
writer.WriteComma();
writer.WritePropertyName(nameof(AttachmentDetails.ContentType));
writer.WriteString(attachment.ContentType);
writer.WriteComma();
writer.WritePropertyName(nameof(AttachmentDetails.Size));
writer.WriteInteger(attachment.Size);
writer.WriteComma();
writer.WritePropertyName(nameof(AttachmentDetails.ChangeVector));
writer.WriteString(attachment.ChangeVector);
writer.WriteComma();
writer.WritePropertyName(nameof(AttachmentDetails.DocumentId));
writer.WriteString(documentId);
writer.WriteEndObject();
}
private static void WriteNode(AsyncBlittableJsonTextWriter writer, ServerNode node, JsonOperationContext context)
{
writer.WriteStartObject();
writer.WritePropertyName(context.GetLazyString(nameof(ServerNode.Url)));
writer.WriteString(context.GetLazyString(node.Url));
writer.WriteComma();
writer.WritePropertyName(context.GetLazyString(nameof(ServerNode.Database)));
writer.WriteString(context.GetLazyString(node.Database));
// ClusterTag and ServerRole included for debugging purpose only
writer.WriteComma();
writer.WritePropertyName(context.GetLazyString(nameof(ServerNode.ClusterTag)));
writer.WriteString(context.GetLazyString(node.ClusterTag));
writer.WriteComma();
writer.WritePropertyName(context.GetLazyString(nameof(ServerNode.ServerRole)));
writer.WriteString(context.GetLazyString(node.ServerRole.ToString()));
writer.WriteEndObject();
}
public async Task DetailedStats()
{
using (var context = QueryOperationContext.Allocate(Database, needsServerContext: true))
using (context.OpenReadTransaction())
{
var stats = new DetailedDatabaseStatistics();
FillDatabaseStatistics(stats, context);
stats.CountOfTimeSeriesDeletedRanges = Database.DocumentsStorage.TimeSeriesStorage.GetNumberOfTimeSeriesDeletedRanges(context.Documents);
using (ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext serverContext))
using (serverContext.OpenReadTransaction())
{
stats.CountOfIdentities = ServerStore.Cluster.GetNumberOfIdentities(serverContext, Database.Name);
stats.CountOfCompareExchange = ServerStore.Cluster.GetNumberOfCompareExchange(serverContext, Database.Name);
stats.CountOfCompareExchangeTombstones = ServerStore.Cluster.GetNumberOfCompareExchangeTombstones(serverContext, Database.Name);
}
await using (var writer = new AsyncBlittableJsonTextWriter(context.Documents, ResponseBodyStream()))
writer.WriteDetailedDatabaseStatistics(context.Documents, stats);
}
}
private static void WriteRange(AsyncBlittableJsonTextWriter writer, TimeSeriesRangeResult rangeResult, long?totalCount)
{
writer.WriteStartObject();
{
writer.WritePropertyName(nameof(TimeSeriesRangeResult.From));
if (rangeResult.From == DateTime.MinValue)
{
writer.WriteNull();
}
else
{
writer.WriteDateTime(rangeResult.From, true);
}
writer.WriteComma();
writer.WritePropertyName(nameof(TimeSeriesRangeResult.To));
if (rangeResult.To == DateTime.MaxValue)
{
writer.WriteNull();
}
else
{
writer.WriteDateTime(rangeResult.To, true);
}
writer.WriteComma();
writer.WritePropertyName(nameof(TimeSeriesRangeResult.Entries));
WriteEntries(writer, rangeResult.Entries);
if (totalCount.HasValue)
{
// add total entries count to the response
writer.WriteComma();
writer.WritePropertyName(nameof(TimeSeriesRangeResult.TotalResults));
writer.WriteInteger(totalCount.Value);
}
}
writer.WriteEndObject();
}
public async Task GetReplicationReconnectionQueue()
{
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
var data = new DynamicJsonArray();
foreach (var queueItem in Database.ReplicationLoader.ReconnectQueue)
{
data.Add(new DynamicJsonValue
{
["Url"] = queueItem.Url,
["Database"] = queueItem.Database,
["Disabled"] = queueItem.Disabled
});
}
context.Write(writer, new DynamicJsonValue
{
["Queue-Info"] = data
});
}
}
public async Task GetStats()
{
var etlStats = GetProcessesToReportOn().Select(x => new EtlTaskStats
{
TaskName = x.Key,
Stats = x.Value.Select(y => new EtlProcessTransformationStats
{
TransformationName = y.TransformationName,
Statistics = y.Statistics
}).ToArray()
}).ToArray();
using (ContextPool.AllocateOperationContext(out JsonOperationContext context))
{
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
writer.WriteStartObject();
writer.WriteArray(context, "Results", etlStats, (w, c, stats) => w.WriteObject(context.ReadObject(stats.ToJson(), "etl/stats")));
writer.WriteEndObject();
}
}
}
public async Task GetPeriodicBackupStatus()
{
var name = GetQueryStringValueAndAssertIfSingleAndNotEmpty("name");
if (await CanAccessDatabaseAsync(name, requireAdmin: false, requireWrite: false) == false)
{
return;
}
var taskId = GetLongQueryString("taskId", required: true);
using (ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
using (context.OpenReadTransaction())
using (var statusBlittable = ServerStore.Cluster.Read(context, PeriodicBackupStatus.GenerateItemName(name, taskId.Value)))
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
writer.WriteStartObject();
writer.WritePropertyName(nameof(GetPeriodicBackupStatusOperationResult.Status));
writer.WriteObject(statusBlittable);
writer.WriteEndObject();
}
}
public async Task TxInfo()
{
var results = new List <TransactionDebugHandler.TransactionInfo>();
var env = Server.ServerStore._env;
var txInfo = new TransactionDebugHandler.TransactionInfo
{
Path = env.Options.BasePath.FullPath,
Information = env.ActiveTransactions.AllTransactionsInstances
};
results.Add(txInfo);
using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context))
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
context.Write(writer, new DynamicJsonValue
{
["tx-info"] = TransactionDebugHandler.ToJson(results)
});
}
}
public async Task Stream()
{
var documentId = GetStringQueryString("docId");
var name = GetStringQueryString("name");
var fromStr = GetStringQueryString("from", required: false);
var toStr = GetStringQueryString("to", required: false);
var offset = GetTimeSpanQueryString("offset", required: false);
var from = string.IsNullOrEmpty(fromStr)
? DateTime.MinValue
: TimeSeriesHandler.ParseDate(fromStr, name);
var to = string.IsNullOrEmpty(toStr)
? DateTime.MaxValue
: TimeSeriesHandler.ParseDate(toStr, name);
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
using (context.OpenReadTransaction())
{
var reader = new TimeSeriesReader(context, documentId, name, from, to, offset);
using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream(), Database.DatabaseShutdown))
{
writer.WriteStartObject();
writer.WritePropertyName("Results");
writer.WriteStartArray();
foreach (var entry in reader.AllValues())
{
context.Write(writer, entry.ToTimeSeriesEntryJson());
writer.WriteComma();
await writer.MaybeOuterFlushAsync();
}
writer.WriteEndArray();
writer.WriteEndObject();
await writer.MaybeOuterFlushAsync();
}
}
}
public async Task GetSettings()
{
ConfigurationEntryScope?scope = null;
var scopeAsString = GetStringQueryString("scope", required: false);
if (scopeAsString != null)
{
if (Enum.TryParse <ConfigurationEntryScope>(scopeAsString, ignoreCase: true, out var value) == false)
{
throw new BadRequestException($"Could not parse '{scopeAsString}' to a valid configuration entry scope.");
}
scope = value;
}
var feature = HttpContext.Features.Get <IHttpAuthenticationFeature>() as RavenServer.AuthenticateConnection;
var status = feature?.Status ?? RavenServer.AuthenticationStatus.ClusterAdmin;
var settingsResult = new SettingsResult();
foreach (var configurationEntryMetadata in RavenConfiguration.AllConfigurationEntries.Value)
{
if (scope.HasValue && scope != configurationEntryMetadata.Scope)
{
continue;
}
var entry = new ConfigurationEntryServerValue(Server.Configuration.Settings, configurationEntryMetadata, status);
settingsResult.Settings.Add(entry);
}
using (ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
{
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
context.Write(writer, settingsResult.ToJson());
}
}
}
public async Task Get()
{
using (ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
{
Dictionary <string, SorterDefinition> sorters;
using (context.OpenReadTransaction())
{
var rawRecord = Server.ServerStore.Cluster.ReadRawDatabaseRecord(context, Database.Name);
sorters = rawRecord?.Sorters;
}
if (sorters == null)
{
sorters = new Dictionary <string, SorterDefinition>();
}
await using (var writer = new AsyncBlittableJsonTextWriter(context, ResponseBodyStream()))
{
writer.WriteStartObject();
writer.WriteArray(context, "Sorters", sorters.Values, (w, c, sorter) =>
{
w.WriteStartObject();
w.WritePropertyName(nameof(SorterDefinition.Name));
w.WriteString(sorter.Name);
w.WriteComma();
w.WritePropertyName(nameof(SorterDefinition.Code));
w.WriteString(sorter.Code);
w.WriteEndObject();
});
writer.WriteEndObject();
}
}
}