public async Task <BlittableJsonReaderObject> ReadFromWebSocket( WebSocket webSocket, string debugTag, CancellationToken cancellationToken) { var jsonParserState = new JsonParserState(); using (var parser = new UnmanagedJsonParser(this, jsonParserState, debugTag)) { var buffer = new ArraySegment <byte>(GetManagedBuffer()); var writer = new BlittableJsonDocumentBuilder(this, BlittableJsonDocumentBuilder.UsageMode.None, debugTag, parser, jsonParserState); writer.ReadObject(); var result = await webSocket.ReceiveAsync(buffer, cancellationToken); if (result.MessageType == WebSocketMessageType.Close) { return(null); } parser.SetBuffer(buffer.Array, result.Count); while (writer.Read() == false) { result = await webSocket.ReceiveAsync(buffer, cancellationToken); parser.SetBuffer(buffer.Array, result.Count); } writer.FinalizeDocument(); return(writer.CreateReader()); } }
private static unsafe BlittableJsonReaderObject ParseJsonOneByteIncrements(string s, JsonOperationContext ctx) { var jsonParserState = new JsonParserState(); var parser = new UnmanagedJsonParser(ctx, jsonParserState, "test"); var builder = new BlittableJsonDocumentBuilder(ctx, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "test", parser, jsonParserState); builder.ReadObjectDocument(); fixed(char *pStr = s) { var buffer = stackalloc byte[1]; for (int i = 0; i < s.Length - 1; i++) { buffer[0] = (byte)pStr[i]; parser.SetBuffer(buffer, 1); Assert.False(builder.Read()); } buffer[0] = (byte)pStr[s.Length - 1]; parser.SetBuffer(buffer, 1); Assert.True(builder.Read()); } builder.FinalizeDocument(); var reader = builder.CreateReader(); return(reader); }
private IEnumerable <(string key, long index, BlittableJsonReaderObject value)> InternalGetCompareExchangeValues() { var state = new JsonParserState(); using (var parser = new UnmanagedJsonParser(_context, state, "Import/CompareExchange")) using (var builder = new BlittableJsonDocumentBuilder(_context, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "Import/CompareExchange", parser, state)) { foreach (var reader in ReadArray()) { using (reader) { if (reader.TryGet("Key", out string key) == false || reader.TryGet("Value", out LazyStringValue value) == false) { _result.CompareExchange.ErroredCount++; _result.AddWarning("Could not read compare exchange entry."); continue; } builder.ReadNestedObject(); SetBuffer(parser, value); parser.Read(); builder.Read(); builder.FinalizeDocument(); yield return(key, 0, builder.CreateReader()); builder.Renew("import/cmpxchg", BlittableJsonDocumentBuilder.UsageMode.ToDisk); } } } }
private static async Task <BlittableJsonReaderArray> ReadJsonArray( JsonOperationContext ctx, Stream stream, UnmanagedJsonParser parser, JsonParserState state, JsonOperationContext.ManagedPinnedBuffer buffer, CancellationToken token) { BlittableJsonReaderArray reader; using (var builder = new BlittableJsonDocumentBuilder( ctx, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "json/array", parser, state)) { ctx.CachedProperties.NewDocument(); builder.ReadArrayDocument(); while (true) { if (builder.Read()) { break; } await RefillParserBuffer(stream, buffer, parser, token); } builder.FinalizeDocument(); reader = builder.CreateArrayReader(noCache: true); } return(reader); }
public void BlittableMetadataModifier_WhileIdContainsNoEscapeCharacters_ResultInLazyStringWithoutEscapeInformation() { const string json = "{\"@metadata\": { \"@id\": \"u1\"}}"; using (var ctx = JsonOperationContext.ShortTermSingleUse()) { var buffer = Encoding.UTF8.GetBytes(json); var state = new JsonParserState(); var modifier = new BlittableMetadataModifier(ctx); using (var parser = new UnmanagedJsonParser(ctx, state, "test")) fixed(byte *pBuffer = buffer) { parser.SetBuffer(pBuffer, buffer.Length); using ( var builder = new BlittableJsonDocumentBuilder(ctx, BlittableJsonDocumentBuilder.UsageMode.None, "test", parser, state, null, modifier)) { builder.ReadObjectDocument(); builder.Read(); builder.FinalizeDocument(); } } Assert.NotNull(modifier.Id.EscapePositions); } }
public unsafe static void RefillParserBuffer(Stream stream, UnmanagedJsonParser parser, CancellationToken token = default) { // Although we using here WithCancellation and passing the token, // the stream will stay open even after the cancellation until the entire server will be disposed. const int size = 8 * 1024 * 1024; var arr = new byte[size]; // var read = stream.Read(buffer.Buffer.Array.Buffer.Offset.Buffer.Count); // .WithCancellation(token); var read = stream.Read(arr, 0, size); // .WithCancellation(token); if (read == 0) { throw new EndOfStreamException(); } var pArr = (byte *)Marshal.AllocHGlobal(read); for (int i = 0; i < read; i++) { *(pArr + i) = arr[i]; } // File.WriteAllBytes("/tmp/aaa" + Guid.NewGuid(), arr); // parser.SetBuffer(buffer, 0, read); parser.SetBuffer(pArr, read); }
private async Task <BlittableJsonReaderObject> Receive(ClientWebSocket webSocket, JsonOperationContext context) { BlittableJsonDocumentBuilder builder = null; try { if (webSocket.State != WebSocketState.Open) { throw new InvalidOperationException( $"Trying to 'ReceiveAsync' WebSocket while not in Open state. State is {webSocket.State}"); } var state = new JsonParserState(); using (context.GetManagedBuffer(out var buffer)) using (var parser = new UnmanagedJsonParser(context, state, "")) { builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, nameof(TrafficRec) + "." + nameof(Receive), parser, state); builder.ReadObjectDocument(); while (builder.Read() == false) { var result = await webSocket.ReceiveAsync(buffer.Buffer, CancellationToken.None); if (result.MessageType == WebSocketMessageType.Close) { if (_logger.IsInfoEnabled) { _logger.Info("Client got close message from server and is closing connection"); } builder.Dispose(); // actual socket close from dispose return(null); } if (result.EndOfMessage == false) { throw new EndOfStreamException("Stream ended without reaching end of json content."); } parser.SetBuffer(buffer, 0, result.Count); } builder.FinalizeDocument(); return(builder.CreateReader()); } } catch (WebSocketException ex) { builder?.Dispose(); if (_logger.IsInfoEnabled) { _logger.Info("Failed to receive a message, client was probably disconnected", ex); } throw; } }
private static void ReadJson(UnmanagedJsonParser parser, MemoryStream stream, JsonParserState state, JsonOperationContext sssssssss) { // var endObj = 1; // while (endObj != 0) // { // ReadNextToken(parser, stream); // if (state.CurrentTokenType == JsonParserToken.EndObject) // { // endObj--; // } // // if (state.CurrentTokenType == JsonParserToken.StartObject) // { // endObj++; // } // } using (var builder = new BlittableJsonDocumentBuilder(parser, state)) { builder.ReadNestedObject(); while (true) { if (builder.Read()) { break; } RefillParserBuffer(stream, parser, new CancellationToken()); // .Wait(); } // builder.FinalizeDocument(); } }
private unsafe bool AboutToReadPropertyNameInternal(UnmanagedJsonParser reader, JsonParserState state) { if (_state != State.None) { if (!AboutToReadWithStateUnlikely(reader, state)) return false; } _state = State.None; while (true) { if (reader.Read() == false) return false; if (state.CurrentTokenType != JsonParserToken.String) return true; // let the caller handle that if (_readingMetadataObject == false) { if (state.StringSize == 9 && state.StringBuffer[0] == (byte)'@' && *(long*)(state.StringBuffer + 1) == 7022344802737087853) _readingMetadataObject = true; return true; } if (AboutToReadPropertyNameInMetadataUnlikely(reader, state, out bool aboutToReadPropertyName)) return aboutToReadPropertyName; } }
public unsafe BlittableJsonReaderObject ParseBuffer(byte *buffer, int length, string debugTag, BlittableJsonDocumentBuilder.UsageMode mode, IBlittableDocumentModifier modifier = null) { if (_disposed) { ThrowObjectDisposed(); } _jsonParserState.Reset(); using (var parser = new UnmanagedJsonParser(this, _jsonParserState, debugTag)) using (var builder = new BlittableJsonDocumentBuilder(this, mode, debugTag, parser, _jsonParserState, modifier: modifier)) { CachedProperties.NewDocument(); builder.ReadObjectDocument(); parser.SetBuffer(buffer, length); if (builder.Read() == false) { throw new EndOfStreamException("Buffer ended without reaching end of json content"); } builder.FinalizeDocument(); var reader = builder.CreateReader(); return(reader); } }
public IDisposable Initialize(DatabaseSmugglerOptions options, SmugglerResult result, out long buildVersion) { _result = result; _returnBuffer = _context.GetManagedBuffer(out _buffer); _state = new JsonParserState(); _parser = new UnmanagedJsonParser(_context, _state, "file"); if (UnmanagedJsonParserHelper.Read(_peepingTomStream, _parser, _state, _buffer) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson("Unexpected end of json.", _peepingTomStream, _parser); } if (_state.CurrentTokenType != JsonParserToken.StartObject) { UnmanagedJsonParserHelper.ThrowInvalidJson("Expected start object, but got " + _state.CurrentTokenType, _peepingTomStream, _parser); } buildVersion = ReadBuildVersion(); _buildVersionType = BuildVersion.Type(buildVersion); _readLegacyEtag = options.ReadLegacyEtag; return(new DisposableAction(() => { _parser.Dispose(); _returnBuffer.Dispose(); _returnWriteBuffer.Dispose(); })); }
public unsafe void Valid_String_With_66K_EscChar() { using (var ctx = JsonOperationContext.ShortTermSingleUse()) { var state = new JsonParserState(); using (var parser = new UnmanagedJsonParser(ctx, state, "test")) { var temp = new Str { str = createRandomEscString(66 * 1024) }; var obj = JObject.FromObject(temp); var objString = obj.ToString(Formatting.None); var buffer = Encoding.UTF8.GetBytes(objString); fixed(byte *pBuffer = buffer) { parser.SetBuffer(pBuffer, buffer.Length); using (var writer = new BlittableJsonDocumentBuilder(ctx, BlittableJsonDocumentBuilder.UsageMode.None, "test", parser, state)) { writer.ReadObjectDocument(); var x = writer.Read(); writer.FinalizeDocument(); using (var reader = writer.CreateReader()) reader.BlittableValidation(); } } } } }
public static async Task <BlittableJsonReaderObject> SimulateSavingToFileAndLoadingAsync(JsonOperationContext context, BlittableJsonReaderObject toStream) { //Simulates saving to file and loading BlittableJsonReaderObject fromStream; await using (Stream stream = new MemoryStream()) { //Pass to stream await using (var textWriter = new AsyncBlittableJsonTextWriter(context, stream)) { context.Write(textWriter, toStream); } //Get from stream stream.Position = 0; var state = new JsonParserState(); var parser = new UnmanagedJsonParser(context, state, "some tag"); var peepingTomStream = new PeepingTomStream(stream, context); using (context.GetMemoryBuffer(out var buffer)) using (var builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, "some tag", parser, state)) { await UnmanagedJsonParserHelper.ReadAsync(peepingTomStream, parser, state, buffer); await UnmanagedJsonParserHelper.ReadObjectAsync(builder, peepingTomStream, parser, buffer); fromStream = builder.CreateReader(); } } return(fromStream); }
public MultiDocumentParser(JsonOperationContext context, Stream stream) { _context = context; _stream = stream; _state = new JsonParserState(); _buffer = context.GetParsingBuffer(); _parser = new UnmanagedJsonParser(context, _state, "parse/multi"); }
public TimeSeriesStreamEnumerator(JsonOperationContext context, PeepingTomStream peepingTomStream, UnmanagedJsonParser parser, JsonParserState state, JsonOperationContext.MemoryBuffer buffer, CancellationToken token = default) { _context = context; _peepingTomStream = peepingTomStream; _parser = parser; _state = state; _buffer = buffer; _token = token; }
public ReadMany(JsonOperationContext ctx, Stream stream, JsonOperationContext.ManagedPinnedBuffer buffer, CancellationToken token) { _stream = stream; _buffer = buffer; _token = token; _state = new JsonParserState(); _parser = new UnmanagedJsonParser(ctx, _state, "bulk_docs"); }
public TimeSeriesStreamEnumerator(InMemoryDocumentSessionOperations session, PeepingTomStream peepingTomStream, UnmanagedJsonParser parser, JsonParserState state, JsonOperationContext.MemoryBuffer buffer, CancellationToken token = default) { _session = session; _peepingTomStream = peepingTomStream; _parser = parser; _state = state; _buffer = buffer; _token = token; }
public MultiDocumentParser(JsonOperationContext context, Stream stream) { _context = context; _stream = stream; var state = new JsonParserState(); _returnManagedBuffer = context.GetManagedBuffer(out _buffer); _parser = new UnmanagedJsonParser(context, state, "parse/multi"); _writer = new BlittableJsonDocumentBuilder(_context, state, _parser); }
public async ValueTask <BlittableJsonReaderObject> ParseToMemoryAsync(WebSocket webSocket, string debugTag, BlittableJsonDocumentBuilder.UsageMode mode, ManagedPinnedBuffer bytes, CancellationToken token = default(CancellationToken) ) { if (_disposed) { ThrowObjectDisposed(); } _jsonParserState.Reset(); UnmanagedJsonParser parser = null; BlittableJsonDocumentBuilder builder = null; var generation = _generation; try { parser = new UnmanagedJsonParser(this, _jsonParserState, debugTag); builder = new BlittableJsonDocumentBuilder(this, mode, debugTag, parser, _jsonParserState); CachedProperties.NewDocument(); builder.ReadObjectDocument(); while (true) { if (bytes.Valid == bytes.Used) { var read = await webSocket.ReceiveAsync(bytes.Buffer, token); EnsureNotDisposed(); if (read.Count == 0) { throw new EndOfStreamException("Stream ended without reaching end of json content"); } bytes.Valid = read.Count; bytes.Used = 0; } parser.SetBuffer(bytes); var result = builder.Read(); bytes.Used += parser.BufferOffset; if (result) { break; } } builder.FinalizeDocument(); var reader = builder.CreateReader(); return(reader); } finally { DisposeIfNeeded(generation, parser, builder); } }
public IEnumerator <BlittableJsonReaderObject> SetResult(StreamResult response) { if (response == null) { throw new InvalidOperationException("The index does not exists, failed to stream results"); } var state = new JsonParserState(); JsonOperationContext.ManagedPinnedBuffer buffer; using (response.Response) using (response.Stream) using (var parser = new UnmanagedJsonParser(_session.Context, state, "stream contents")) using (_session.Context.GetManagedBuffer(out buffer)) using (var peepingTomStream = new PeepingTomStream(response.Stream, _session.Context)) { if (UnmanagedJsonParserHelper.Read(peepingTomStream, parser, state, buffer) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(peepingTomStream); } if (state.CurrentTokenType != JsonParserToken.StartObject) { UnmanagedJsonParserHelper.ThrowInvalidJson(peepingTomStream); } if (_isQueryStream) { HandleStreamQueryStats(_session.Context, response, parser, state, buffer, _statistics); } var property = UnmanagedJsonParserHelper.ReadString(_session.Context, peepingTomStream, parser, state, buffer); if (string.Equals(property, "Results") == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(peepingTomStream); } foreach (var result in UnmanagedJsonParserHelper.ReadArrayToMemory(_session.Context, peepingTomStream, parser, state, buffer)) { yield return(result); } if (UnmanagedJsonParserHelper.Read(peepingTomStream, parser, state, buffer) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(peepingTomStream); } if (state.CurrentTokenType != JsonParserToken.EndObject) { UnmanagedJsonParserHelper.ThrowInvalidJson(peepingTomStream); } } }
private static void ReadNextToken(Stream stream, UnmanagedJsonParser parser, JsonOperationContext.ManagedPinnedBuffer buffer) { while (parser.Read() == false) { var read = stream.Read(buffer.Buffer.Array, buffer.Buffer.Offset, buffer.Buffer.Count); if (read == 0) { throw new EndOfStreamException("The stream ended unexpectedly"); } parser.SetBuffer(buffer, read); } }
public override void SetResponseRaw(HttpResponseMessage response, Stream stream, JsonOperationContext context) { var state = new JsonParserState(); using (var parser = new UnmanagedJsonParser(context, state, "multi_get/response")) using (context.GetMemoryBuffer(out var buffer)) using (var peepingTomStream = new PeepingTomStream(stream, context)) using (_cached) { if (UnmanagedJsonParserHelper.Read(peepingTomStream, parser, state, buffer) == false) { ThrowInvalidJsonResponse(peepingTomStream); } if (state.CurrentTokenType != JsonParserToken.StartObject) { ThrowInvalidJsonResponse(peepingTomStream); } var property = UnmanagedJsonParserHelper.ReadString(context, peepingTomStream, parser, state, buffer); if (property != nameof(BlittableArrayResult.Results)) { ThrowInvalidJsonResponse(peepingTomStream); } var i = 0; Result = new List <GetResponse>(_commands.Count); foreach (var getResponse in ReadResponses(context, peepingTomStream, parser, state, buffer)) { var command = _commands[i]; MaybeSetCache(getResponse, command); Result.Add(_cached != null && getResponse.StatusCode == HttpStatusCode.NotModified ? new GetResponse { Result = _cached.Values[i].Cached.Clone(context), StatusCode = HttpStatusCode.NotModified } : getResponse); i++; } if (UnmanagedJsonParserHelper.Read(peepingTomStream, parser, state, buffer) == false) { ThrowInvalidJsonResponse(peepingTomStream); } if (state.CurrentTokenType != JsonParserToken.EndObject) { ThrowInvalidJsonResponse(peepingTomStream); } } }
private void DisposeIfNeeded(int generation, UnmanagedJsonParser parser, BlittableJsonDocumentBuilder builder) { // if the generation has changed, that means that we had reset the context // this can happen if we were waiting on an async call for a while, got timed out / error / something // and the context was reset before we got back from the async call // since the full context was reset, there is no point in trying to dispose things, they were already // taken care of if (generation == _generation) { parser?.Dispose(); builder?.Dispose(); } }
public async Task InitializeAsync() { AssertNotSync(); try { _initialized = true; _state = new JsonParserState(); _parser = new UnmanagedJsonParser(_session.Context, _state, "stream contents"); _returnBuffer = _session.Context.GetManagedBuffer(out _buffer); if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer).ConfigureAwait(false) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } if (_state.CurrentTokenType != JsonParserToken.StartObject) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } if (_isQueryStream) { HandleStreamQueryStats(_session.Context, _response, _parser, _state, _buffer, _streamQueryStatistics); } var property = UnmanagedJsonParserHelper.ReadString(_session.Context, _peepingTomStream, _parser, _state, _buffer); if (string.Equals(property, "Results") == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer).ConfigureAwait(false) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } if (_state.CurrentTokenType != JsonParserToken.StartArray) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } } catch { Dispose(); throw; } }
public unsafe void Valid_String() { using (var ctx = JsonOperationContext.ShortTermSingleUse()) { var state = new JsonParserState(); using (var parser = new UnmanagedJsonParser(ctx, state, "test")) { var temp = new Str { str = "\nabcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz" + "abcdefghijklmnopqrstuvwxyz\n" }; var obj = RavenJObject.FromObject(temp); var objString = obj.ToString(Formatting.None); var buffer = Encoding.UTF8.GetBytes(objString); fixed(byte *pBuffer = buffer) { parser.SetBuffer(pBuffer, buffer.Length); var writer = new BlittableJsonDocumentBuilder(ctx, BlittableJsonDocumentBuilder.UsageMode.None, "test", parser, state); writer.ReadObjectDocument(); var x = writer.Read(); writer.FinalizeDocument(); var reader = writer.CreateReader(); reader.BlittableValidation(); } } } }
public override void SetResponseRaw(HttpResponseMessage response, Stream stream, JsonOperationContext context) { var state = new JsonParserState(); using (var parser = new UnmanagedJsonParser(context, state, "multi_get/response")) using (context.GetManagedBuffer(out JsonOperationContext.ManagedPinnedBuffer buffer)) using (var peepingTomStream = new PeepingTomStream(stream, context)) { if (UnmanagedJsonParserHelper.Read(peepingTomStream, parser, state, buffer) == false) { ThrowInvalidJsonResponse(peepingTomStream); } if (state.CurrentTokenType != JsonParserToken.StartObject) { ThrowInvalidJsonResponse(peepingTomStream); } var property = UnmanagedJsonParserHelper.ReadString(context, peepingTomStream, parser, state, buffer); if (property != nameof(BlittableArrayResult.Results)) { ThrowInvalidJsonResponse(peepingTomStream); } var i = 0; Result = new List <GetResponse>(); foreach (var getResponse in ReadResponses(context, peepingTomStream, parser, state, buffer)) { var command = _commands[i]; MaybeSetCache(getResponse, command); MaybeReadFromCache(getResponse, command, context); Result.Add(getResponse); i++; } if (UnmanagedJsonParserHelper.Read(peepingTomStream, parser, state, buffer) == false) { ThrowInvalidJsonResponse(peepingTomStream); } if (state.CurrentTokenType != JsonParserToken.EndObject) { ThrowInvalidJsonResponse(peepingTomStream); } } }
public unsafe void Valid_object_read_from_non_zero_offset() { using (var context = JsonOperationContext.ShortTermSingleUse()) { var jsonParserState = new JsonParserState(); using (var parser = new UnmanagedJsonParser(context, jsonParserState, "changes/1")) { byte[] buffer = new byte[4096]; var bufferOffset = 128; //non-zero offset var allTokens = new AllTokensTypes { Bool = true, Float = 123.4567F, Int = 45679123, IntArray = new[] { 1, 2, 3 }, Null = null, Object = new Empty(), String = "qwertyuio" }; var obj = JObject.FromObject(allTokens); var objString = obj.ToString(Formatting.None); var data = Encoding.UTF8.GetBytes(objString); data.CopyTo(buffer, bufferOffset); fixed(byte *pBuffer = buffer) { using (var builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, "order/1", parser, jsonParserState)) { parser.SetBuffer(pBuffer + bufferOffset, data.Length); builder.ReadObjectDocument(); Assert.True(builder.Read()); builder.FinalizeDocument(); using (var reader = builder.CreateReader()) { var value = reader.ToString(); Assert.NotNull(value); } } } } } }
private static unsafe BlittableJsonReaderObject ParseJsonAllAtOnce(string s, JsonOperationContext ctx) { var jsonParserState = new JsonParserState(); var parser = new UnmanagedJsonParser(ctx, jsonParserState, "test"); var builder = new BlittableJsonDocumentBuilder(ctx, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "test", parser, jsonParserState); builder.ReadObjectDocument(); var value = ctx.GetLazyString(s); parser.SetBuffer(value.Buffer, value.Size); Assert.True(builder.Read()); builder.FinalizeDocument(); var reader = builder.CreateReader(); return(reader); }
private async Task HandleBatchOfDocuments(DocumentsOperationContext context, UnmanagedJsonParser parser, long buildVersion) { if (_batchPutCommand.TotalSize >= 16 * Voron.Global.Constants.Size.Megabyte) { if (_prevCommand != null) { using (_prevCommand) { await _prevCommandTask; ResetContextAndParser(context, parser); } } _prevCommandTask = _database.TxMerger.Enqueue(_batchPutCommand); _prevCommand = _batchPutCommand; _batchPutCommand = new MergedBatchPutCommand(_database, buildVersion); } }
private static void ReadNextToken(UnmanagedJsonParser parser, MemoryStream stream, bool isFirst = false) { if (parser.Read() == false) { RefillParserBuffer(stream, parser, CancellationToken.None); //.Wait(); if (parser.Read() == false) { Console.WriteLine("OMASMASDAS"); Environment.Exit(2222); } } else if (isFirst) { Console.WriteLine("ERRRRRRRRR"); Console.Out.Flush(); } }