public override void SetResponse(JsonOperationContext context, BlittableJsonReaderObject response, bool fromCache) { Result = (TResult)(object)response; }
public override void SetResponse(JsonOperationContext context, BlittableJsonReaderObject response, bool fromCache) { Result = JsonDeserializationClient.AttachmentDetails(response); }
public RavenCommand <ModifySolverResult> GetCommand(DocumentConventions conventions, JsonOperationContext ctx) { return(new ModifyConflictSolverCommand(conventions, _database, this)); }
public RavenCommand GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new StartTransactionsRecordingCommand(_filePath)); }
protected override Task PerformHealthCheck(ServerNode serverNode, int nodeIndex, JsonOperationContext context) { return(ExecuteAsync(serverNode, nodeIndex, context, new GetTcpInfoCommand("health-check"), shouldRetry: false, sessionInfo: null, token: CancellationToken.None)); }
public RavenCommand GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new StopIndexingCommand()); }
public override void SetResponse(JsonOperationContext context, BlittableJsonReaderObject response, bool fromCache) { Result = JsonDeserializationClient.PutIndexesResponse(response).Results; }
private async Task HandleRequestAsync( BlittableJsonReaderObject request, JsonOperationContext context, MultiGetHttpResponseStream responseStream, BlittableJsonTextWriter writer, HttpContext httpContext, HostString host, string scheme, LazyStringValue resultProperty, LazyStringValue statusProperty, LazyStringValue headersProperty, StringBuilder trafficWatchStringBuilder) { writer.WriteStartObject(); if (request.TryGet(nameof(GetRequest.Url), out string url) == false || request.TryGet(nameof(GetRequest.Query), out string query) == false) { writer.WriteEndObject(); return; } if (request.TryGet(nameof(GetRequest.Method), out string method) == false || string.IsNullOrEmpty(method)) { method = HttpMethod.Get.Method; } httpContext.Request.Method = method; var routeInformation = Server.Router.GetRoute(method, url, out RouteMatch localMatch); if (routeInformation == null) { HandleNoRoute(context, writer, method, url, query, statusProperty, resultProperty); return; } var requestHandler = routeInformation.GetRequestHandler(); writer.WritePropertyName(resultProperty); writer.Flush(); PrepareHttpContext(request, context, httpContext, method, query, host, scheme, trafficWatchStringBuilder, out var content); var bytesWrittenBeforeRequest = responseStream.BytesWritten; int statusCode; try { if (Server.Configuration.Security.AuthenticationEnabled == false || Server.Router.TryAuthorize(routeInformation, httpContext, Database, out var status)) { await requestHandler(new RequestHandlerContext { Database = Database, RavenServer = Server, RouteMatch = localMatch, HttpContext = httpContext }); } if (bytesWrittenBeforeRequest == responseStream.BytesWritten) { writer.WriteNull(); } statusCode = httpContext.Response.StatusCode == 0 ? (int)HttpStatusCode.OK : httpContext.Response.StatusCode; } catch (Exception e) { if (bytesWrittenBeforeRequest != responseStream.BytesWritten) { throw; } statusCode = (int)HttpStatusCode.InternalServerError; HandleException(context, writer, e, url, query); } writer.WriteComma(); writer.WritePropertyName(statusProperty); writer.WriteInteger(statusCode); writer.WriteComma(); WriteHeaders(writer, httpContext, headersProperty); writer.WriteEndObject(); trafficWatchStringBuilder?.Append(content).AppendLine(); }
public RavenCommand GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new ResetIndexCommand(_indexName)); }
internal static unsafe BlittableJsonReaderObject ParseJsonStringIntoBlittable(string json, JsonOperationContext context) { var bytes = Encoding.UTF8.GetBytes(json); fixed(byte *ptr = bytes) { var blittableJson = context.ParseBuffer(ptr, bytes.Length, "MoreLikeThis/ExtractTermsFromJson", BlittableJsonDocumentBuilder.UsageMode.None); blittableJson.BlittableValidation(); //precaution, needed because this is user input.. return(blittableJson); } }
public static void WaitForIndexing(IDocumentStore store, string dbName = null, TimeSpan?timeout = null) { var admin = store.Admin.ForDatabase(dbName); timeout = timeout ?? (Debugger.IsAttached ? TimeSpan.FromMinutes(15) : TimeSpan.FromMinutes(1)); var sp = Stopwatch.StartNew(); while (sp.Elapsed < timeout.Value) { var databaseStatistics = admin.Send(new GetStatisticsOperation()); var indexes = databaseStatistics.Indexes .Where(x => x.State != IndexState.Disabled); if (indexes.All(x => x.IsStale == false && x.Name.StartsWith("ReplacementOf/") == false)) { return; } if (databaseStatistics.Indexes.Any(x => x.State == IndexState.Error)) { break; } Thread.Sleep(32); } var perf = admin.Send(new GetIndexPerformanceStatisticsOperation()); var errors = admin.Send(new GetIndexErrorsOperation()); var stats = admin.Send(new GetIndexesStatisticsOperation()); var total = new { Errors = errors, Stats = stats, Performance = perf }; var file = Path.GetTempFileName() + ".json"; using (var stream = File.Open(file, FileMode.OpenOrCreate)) using (var context = JsonOperationContext.ShortTermSingleUse()) using (var writer = new BlittableJsonTextWriter(context, stream)) { var djv = (DynamicJsonValue)TypeConverter.ToBlittableSupportedType(total); var json = context.ReadObject(djv, "errors"); writer.WriteObject(json); writer.Flush(); } var statistics = admin.Send(new GetStatisticsOperation()); var corrupted = statistics.Indexes.Where(x => x.State == IndexState.Error).ToList(); if (corrupted.Count > 0) { throw new InvalidOperationException( $"The following indexes are with error state: {string.Join(",", corrupted.Select(x => x.Name))} - details at " + file); } throw new TimeoutException("The indexes stayed stale for more than " + timeout.Value + ", stats at " + file); }
private Dictionary <string, Dictionary <string, string[]> > GetHighlighterResults(IndexQueryServerSide query, IndexSearcher searcher, ScoreDoc scoreDoc, Document document, global::Lucene.Net.Documents.Document luceneDocument, JsonOperationContext context) { Debug.Assert(_highlighter != null); Debug.Assert(_highlighterQuery != null); var results = new Dictionary <string, Dictionary <string, string[]> >(); foreach (var highlighting in query.Metadata.Highlightings) { var fieldName = highlighting.Field.Value; var indexFieldName = query.Metadata.IsDynamic ? AutoIndexField.GetSearchAutoIndexFieldName(fieldName) : fieldName; var fragments = _highlighter.GetBestFragments( _highlighterQuery, searcher.IndexReader, scoreDoc.Doc, indexFieldName, highlighting.FragmentLength, highlighting.FragmentCount, _state); if (fragments == null || fragments.Length == 0) { continue; } var options = highlighting.GetOptions(context, query.QueryParameters); string key; if (options != null && string.IsNullOrWhiteSpace(options.GroupKey) == false) { key = luceneDocument.Get(options.GroupKey, _state); } else { key = document.Id; } if (results.TryGetValue(fieldName, out var result) == false) { results[fieldName] = result = new Dictionary <string, string[]>(); } if (result.TryGetValue(key, out var innerResult)) { Array.Resize(ref innerResult, innerResult.Length + fragments.Length); Array.Copy(fragments, 0, innerResult, innerResult.Length, fragments.Length); } else { result[key] = fragments; } } return(results); }
public override TransactionOperationsMerger.IReplayableCommandDto <TransactionOperationsMerger.MergedTransactionCommand> ToDto(JsonOperationContext context) { throw new NotSupportedException($"ToDto() of {nameof(ExecuteRateLimitedOperations<T>)} Should not be called"); }
public async Task PutDifferentAttachmentsShouldConflict() { using (var store1 = GetDocumentStore(options: new Options { ModifyDatabaseRecord = record => { record.ConflictSolverConfig = new ConflictSolver(); } })) using (var store2 = GetDocumentStore(options: new Options { ModifyDatabaseRecord = record => { record.ConflictSolverConfig = new ConflictSolver(); } })) { await SetDatabaseId(store1, new Guid("00000000-48c4-421e-9466-000000000000")); await SetDatabaseId(store2, new Guid("99999999-48c4-421e-9466-999999999999")); using (var session = store1.OpenAsyncSession()) { var x = new User { Name = "Fitzchak" }; await session.StoreAsync(x, "users/1"); await session.SaveChangesAsync(); using (var a1 = new MemoryStream(new byte[] { 1, 2, 3 })) { await store1.Operations.SendAsync(new PutAttachmentOperation("users/1", "a1", a1, "a1/png")); } using (var session2 = store2.OpenSession()) { session2.Store(new User { Name = "Fitzchak" }, "users/1"); session2.SaveChanges(); using (var a2 = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 })) { store2.Operations.Send(new PutAttachmentOperation("users/1", "a1", a2, "a1/png")); } await SetupReplicationAsync(store1, store2); await session.StoreAsync(new User { Name = "Toli" }, "users/2"); await session.SaveChangesAsync(); WaitForDocumentToReplicate <User>(store2, "users/2", 3000); var conflicts = (await store2.Commands().GetConflictsForAsync("users/1")).ToList(); Assert.Equal(2, conflicts.Count); var requestExecutor = store2.GetRequestExecutor(); using (var context = JsonOperationContext.ShortTermSingleUse()) using (var stringStream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(_conflictedDocument))) using (var blittableJson = context.Read(stringStream, "Reading of foo/bar")) { var result = new InMemoryDocumentSessionOperations.SaveChangesData((InMemoryDocumentSessionOperations)session2); result.SessionCommands.Add(new PutCommandDataWithBlittableJson("users/1", null, blittableJson)); var sbc = new SingleNodeBatchCommand(DocumentConventions.Default, context, result.SessionCommands, result.Options); await requestExecutor.ExecuteAsync(sbc, context); } } } using (var session = store1.OpenAsyncSession()) { var conflicts = (await store2.Commands().GetConflictsForAsync("users/1")).ToList(); Assert.Equal(0, conflicts.Count); Assert.True(await session.Advanced.Attachments.ExistsAsync("users/1", "a1")); } } }
public override void SetResponseRaw(HttpResponseMessage response, Stream stream, JsonOperationContext context) { if (response == null) { return; } var ms = new MemoryStream(); stream.CopyTo(ms); Result = new CertificateRawData { RawData = ms.ToArray() }; }
protected override void LoadInternal(IEnumerable <SqlTableWithRecords> records, JsonOperationContext context) { using (var writer = new RelationalDatabaseWriter(this, Database)) { foreach (var table in records) { var stats = writer.Write(table, null, CancellationToken); LogStats(stats, table); } writer.Commit(); } }
public RavenCommand <CertificateRawData> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new CreateClientCertificateCommand(_name, _permissions, _clearance, _password)); }
public RavenCommand <ConfigureTimeSeriesOperationResult> GetCommand(DocumentConventions conventions, JsonOperationContext ctx) { return(new ConfigureTimeSeriesValueNamesCommand(_parameters)); }
public RavenCommand <PutIndexResult[]> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new PutIndexesCommand(conventions, context, _indexToAdd)); }
public RavenCommand <DatabasePutResult> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new CreateDatabaseOperation.CreateDatabaseCommand(_databaseRecord, _replicationFactor)); }
public PatchDocumentCommand( JsonOperationContext context, string id, LazyStringValue expectedChangeVector, bool skipPatchIfChangeVectorMismatch, (PatchRequest run, BlittableJsonReaderObject args) patch,
public void ValidateFailedRevisionsSubscriptionScriptExceptionHandling() { using (var store = GetDocumentStore()) { using (var context = JsonOperationContext.ShortTermSingleUse()) { var configuration = new RevisionsConfiguration { Default = new RevisionsCollectionConfiguration { Disabled = false, MinimumRevisionsToKeep = 5, }, Collections = new Dictionary <string, RevisionsCollectionConfiguration> { ["Users"] = new RevisionsCollectionConfiguration { Disabled = false }, ["Dons"] = new RevisionsCollectionConfiguration { Disabled = false } } }; AsyncHelpers.RunSync(() => Server.ServerStore.ModifyDatabaseRevisions(context, store.Database, EntityToBlittable.ConvertCommandToBlittable(configuration, context), Guid.NewGuid().ToString())); } var subscriptionId = store.Subscriptions.Create(new SubscriptionCreationOptions() { Query = @" declare function project(d){ throw 'nice'; return d; } from Users (Revisions = true) as d select project(d) " }); var subscription = store.Subscriptions.GetSubscriptionWorker <User>(new SubscriptionWorkerOptions(subscriptionId) { TimeToWaitBeforeConnectionRetry = TimeSpan.FromSeconds(5) }); var exceptions = new List <Exception>(); var mre = new ManualResetEvent(false); var receivedItem = new SubscriptionBatch <User> .Item(); var userId = string.Empty; using (var session = store.OpenSession()) { var newUser = new User(); session.Store(newUser); session.SaveChanges(); userId = session.Advanced.GetDocumentId(newUser); } subscription.Run(x => { foreach (var item in x.Items) { receivedItem = item; try { var res = item; } catch (Exception e) { exceptions.Add(e); } } mre.Set(); }); Assert.True(mre.WaitOne(_reasonableWaitTime)); Assert.NotNull(receivedItem); Assert.Throws <InvalidOperationException>(() => receivedItem.Result); Assert.NotNull(receivedItem.Metadata); Assert.Equal(receivedItem.Id, userId); } }
public override TransactionOperationsMerger.IReplayableCommandDto <TransactionOperationsMerger.MergedTransactionCommand> ToDto(JsonOperationContext context) { return(new ExecuteCounterBatchCommandDto { Dictionary = _dictionary, ReplyWithAllNodesValues = _replyWithAllNodesValues, FromEtl = _fromEtl }); }
public RavenCommand <CertificateMetadata> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new GetCertificateMetadataCommand(_thumbprint)); }
public RavenCommand <AttachmentDetails> GetCommand(IDocumentStore store, DocumentConventions conventions, JsonOperationContext context, HttpCache cache) { return(new PutAttachmentCommand(_documentId, _name, _stream, _contentType, _changeVector)); }
protected override int GetFields <T>(T instance, LazyStringValue key, object document, JsonOperationContext indexContext) { int newFields = 0; if (key != null) { instance.Add(GetOrCreateKeyField(key)); newFields++; } var boostedValue = document as BoostedValue; var documentToProcess = boostedValue == null ? document : boostedValue.Value; PropertyAccessor accessor; if (_isMultiMap == false) { accessor = _propertyAccessor ?? (_propertyAccessor = PropertyAccessor.Create(documentToProcess.GetType())); } else { accessor = TypeConverter.GetPropertyAccessor(documentToProcess); } var reduceResult = _reduceOutput ? new DynamicJsonValue() : null; foreach (var property in accessor.PropertiesInOrder) { var value = property.Value.GetValue(documentToProcess); IndexField field; try { field = _fields[property.Key]; } catch (KeyNotFoundException e) { throw new InvalidOperationException($"Field '{property.Key}' is not defined. Available fields: {string.Join(", ", _fields.Keys)}.", e); } var boostedFields = GetRegularFields(instance, field, value, indexContext); newFields += boostedFields; if (boostedValue != null) { var fields = instance.GetFields(); for (int idx = fields.Count - 1; boostedFields > 0; boostedFields--, idx--) { var luceneField = fields[idx]; luceneField.Boost = boostedValue.Boost; luceneField.OmitNorms = false; } } if (reduceResult != null) { reduceResult[property.Key] = TypeConverter.ToBlittableSupportedType(value, flattenArrays: true); } } if (_reduceOutput) { instance.Add(GetReduceResultValueField(Scope.CreateJson(reduceResult, indexContext))); newFields++; } return(newFields); }
protected override BlittableJsonReaderObject GetUpdatedValue(long index, RawDatabaseRecord record, JsonOperationContext context, BlittableJsonReaderObject existingValue) { throw new NotImplementedException(); }
public RavenCommand <DatabasePutResult> GetCommand(DocumentConventions conventions, JsonOperationContext ctx) { return(new CreateDatabaseCommand(conventions, _databaseRecord, this)); }
public RavenCommand <ReplicationPerformance> GetCommand(DocumentConventions conventions, JsonOperationContext context) { return(new GetReplicationPerformanceStatisticsCommand(conventions)); }
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); } } }