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 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); }
public async Task <bool> MoveNextAsync() { if (_initialized == false) { await InitializeAsync().ConfigureAwait(false); } if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer).ConfigureAwait(false) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } if (_state.CurrentTokenType == JsonParserToken.EndArray) { if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer).ConfigureAwait(false) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } if (_state.CurrentTokenType != JsonParserToken.EndObject) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } return(false); } using (var builder = new BlittableJsonDocumentBuilder(_session.Context, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "readArray/singleResult", _parser, _state)) { await UnmanagedJsonParserHelper.ReadObjectAsync(builder, _peepingTomStream, _parser, _buffer).ConfigureAwait(false); Current = builder.CreateReader(); return(true); } }
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 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); }
private static async Task <BlittableJsonReaderObject> ReadJsonObject(JsonOperationContext ctx, Stream stream, string id, UnmanagedJsonParser parser, JsonParserState state, JsonOperationContext.ManagedPinnedBuffer buffer, CancellationToken token) { if (state.CurrentTokenType == JsonParserToken.Null) { return(null); } BlittableJsonReaderObject reader; using (var builder = new BlittableJsonDocumentBuilder(ctx, BlittableJsonDocumentBuilder.UsageMode.ToDisk, id, parser, state, modifier: new BlittableMetadataModifier(ctx))) { ctx.CachedProperties.NewDocument(); builder.ReadNestedObject(); while (true) { if (builder.Read()) { break; } await RefillParserBuffer(stream, buffer, parser, token); } builder.FinalizeDocument(); reader = builder.CreateReader(); reader.NoCache = true; } return(reader); }
public static IEnumerable <BlittableJsonReaderObject> ReadArrayToMemory(JsonOperationContext context, PeepingTomStream peepingTomStream, UnmanagedJsonParser parser, JsonParserState state, JsonOperationContext.ManagedPinnedBuffer buffer) { if (Read(peepingTomStream, parser, state, buffer) == false) { ThrowInvalidJson(peepingTomStream); } if (state.CurrentTokenType != JsonParserToken.StartArray) { ThrowInvalidJson(peepingTomStream); } while (true) { if (Read(peepingTomStream, parser, state, buffer) == false) { ThrowInvalidJson(peepingTomStream); } if (state.CurrentTokenType == JsonParserToken.EndArray) { break; } using (var builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, "readArray/singleResult", parser, state)) { ReadObject(builder, peepingTomStream, parser, buffer); yield return(builder.CreateReader()); } } }
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); }
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); } } } }
public async Task <bool> MoveNextAsync() { if (_initialized == false) { await InitializeAsync().ConfigureAwait(false); } if (_docsCountOnCachedRenewSession <= 16 * 1024) { if (_cachedItemsRenew) { _session.Context.CachedProperties = new CachedProperties(_session.Context); ++_docsCountOnCachedRenewSession; } } else { _session.Context.Renew(); _docsCountOnCachedRenewSession = 0; } if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer).ConfigureAwait(false) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } if (_state.CurrentTokenType == JsonParserToken.EndArray) { if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer).ConfigureAwait(false) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } if (_state.CurrentTokenType != JsonParserToken.EndObject) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } return(false); } using (var builder = new BlittableJsonDocumentBuilder(_session.Context, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "readArray/singleResult", _parser, _state)) { if (_cachedItemsRenew == false) { _cachedItemsRenew = builder.NeedResetPropertiesCache(); } await UnmanagedJsonParserHelper.ReadObjectAsync(builder, _peepingTomStream, _parser, _buffer).ConfigureAwait(false); Current = builder.CreateReader(); return(true); } }
public static IEnumerable <BlittableJsonReaderObject> ReadArrayToMemory(JsonOperationContext context, PeepingTomStream peepingTomStream, UnmanagedJsonParser parser, JsonParserState state, JsonOperationContext.ManagedPinnedBuffer buffer) { if (Read(peepingTomStream, parser, state, buffer) == false) { ThrowInvalidJson(peepingTomStream); } if (state.CurrentTokenType != JsonParserToken.StartArray) { ThrowInvalidJson(peepingTomStream); } int docsCountOnCachedRenewSession = 0; bool cachedItemsRenew = false; while (true) { if (docsCountOnCachedRenewSession <= 16 * 1024) { if (cachedItemsRenew) { context.CachedProperties = new CachedProperties(context); ++docsCountOnCachedRenewSession; } } else { context.Renew(); docsCountOnCachedRenewSession = 0; } if (Read(peepingTomStream, parser, state, buffer) == false) { ThrowInvalidJson(peepingTomStream); } if (state.CurrentTokenType == JsonParserToken.EndArray) { break; } using (var builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, "readArray/singleResult", parser, state)) { if (cachedItemsRenew == false) { cachedItemsRenew = builder.NeedResetPropertiesCache(); } ReadObject(builder, peepingTomStream, parser, buffer); yield return(builder.CreateReader()); } } }
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 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); } } } } } }
public static void ReadObject(BlittableJsonDocumentBuilder builder, PeepingTomStream peepingTomStream, UnmanagedJsonParser parser, JsonOperationContext.ManagedPinnedBuffer buffer) { builder.ReadNestedObject(); while (builder.Read() == false) { var read = peepingTomStream.Read(buffer.Buffer.Array, buffer.Buffer.Offset, buffer.Length); if (read == 0) { throw new EndOfStreamException("Stream ended without reaching end of json content" + GetPeepingTomBufferAsString(peepingTomStream)); } parser.SetBuffer(buffer, 0, read); } builder.FinalizeDocument(); }
public static void ReadProperty(BlittableJsonDocumentBuilder builder, PeepingTomStream peepingTomStream, UnmanagedJsonParser parser, JsonOperationContext.MemoryBuffer buffer) { builder.ReadProperty(); while (builder.Read() == false) { var read = peepingTomStream.Read(buffer.Memory.Memory.Span); if (read == 0) { throw new EndOfStreamException("Stream ended without reaching end of json content" + GetPeepingTomBufferAsString(peepingTomStream)); } parser.SetBuffer(buffer, 0, read); } builder.FinalizeDocument(); }
public static async Task ReadObjectAsync(BlittableJsonDocumentBuilder builder, PeepingTomStream peepingTomStream, UnmanagedJsonParser parser, JsonOperationContext.ManagedPinnedBuffer buffer) { builder.ReadNestedObject(); while (builder.Read() == false) { var read = await peepingTomStream.ReadAsync(buffer.Buffer.Array, buffer.Buffer.Offset, buffer.Length).ConfigureAwait(false); if (read == 0) { throw new EndOfStreamException("Stream ended without reaching end of json content"); } parser.SetBuffer(buffer, 0, read); } builder.FinalizeDocument(); }
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); }
public static async Task ReadObjectAsync(BlittableJsonDocumentBuilder builder, PeepingTomStream peepingTomStream, UnmanagedJsonParser parser, JsonOperationContext.MemoryBuffer buffer, CancellationToken token = default) { builder.ReadNestedObject(); while (builder.Read() == false) { var read = await peepingTomStream.ReadAsync(buffer.Memory.Memory, token).ConfigureAwait(false); if (read == 0) { throw new EndOfStreamException("Stream ended without reaching end of json content"); } parser.SetBuffer(buffer, 0, read); } builder.FinalizeDocument(); }
public override async Task <ResponseDisposeHandling> ProcessResponse(JsonOperationContext context, HttpCache cache, HttpResponseMessage response, string url) { var state = new JsonParserState(); Stream stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false); using (context.GetMemoryBuffer(out var buffer)) using (var parser = new UnmanagedJsonParser(context, state, "attachments/receive")) using (var builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, "attachments/list", parser, state)) using (var peepingTomStream = new PeepingTomStream(stream, context)) { if (await UnmanagedJsonParserHelper.ReadAsync(peepingTomStream, parser, state, buffer).ConfigureAwait(false) == false) { throw new Exception("cannot parse stream"); } if (state.CurrentTokenType != JsonParserToken.StartObject) { throw new Exception($"Expected token {nameof(JsonParserToken.StartObject)}, but got {nameof(state.CurrentTokenType)}."); } await UnmanagedJsonParserHelper.ReadObjectAsync(builder, peepingTomStream, parser, buffer).ConfigureAwait(false); using (var data = builder.CreateReader()) { if (data.TryGetMember(nameof(AttachmentsMetadata), out object obj) && obj is BlittableJsonReaderArray bjra) { foreach (BlittableJsonReaderObject e in bjra) { var cur = JsonDeserializationClient.AttachmentDetails(e); AttachmentsMetadata.Add(cur); } } } var bufferSize = parser.BufferSize - parser.BufferOffset; var copy = ArrayPool <byte> .Shared.Rent(bufferSize); var copyMemory = new Memory <byte>(copy); buffer.Memory.Memory.Slice(parser.BufferOffset, bufferSize).CopyTo(copyMemory); Result = Iterate(stream, copy, bufferSize).GetEnumerator(); } return(ResponseDisposeHandling.Manually); }
public void FailsOnInvalidJson(string invalidJson) { using (var ctx = JsonOperationContext.ShortTermSingleUse()) { var buffer = Encoding.UTF8.GetBytes(invalidJson); var state = new JsonParserState(); fixed(byte *pBuffer = buffer) { using (var parser = new UnmanagedJsonParser(ctx, state, "test")) { parser.SetBuffer(pBuffer, buffer.Length); var writer = new BlittableJsonDocumentBuilder(ctx, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "test", parser, state); writer.ReadObjectDocument(); Assert.Throws <InvalidDataException>(() => writer.Read()); } } } }
public static BlittableJsonReaderObject ParseToMemory( this JsonOperationContext.SyncJsonOperationContext syncContext, Stream stream, string debugTag, BlittableJsonDocumentBuilder.UsageMode mode, JsonOperationContext.MemoryBuffer bytes, IBlittableDocumentModifier modifier = null) { syncContext.EnsureNotDisposed(); syncContext.JsonParserState.Reset(); using (var parser = new UnmanagedJsonParser(syncContext.Context, syncContext.JsonParserState, debugTag)) using (var builder = new BlittableJsonDocumentBuilder(syncContext.Context, mode, debugTag, parser, syncContext.JsonParserState, modifier: modifier)) { syncContext.Context.CachedProperties.NewDocument(); builder.ReadObjectDocument(); while (true) { if (bytes.Valid == bytes.Used) { var read = stream.Read(bytes.Memory.Memory.Span); syncContext.EnsureNotDisposed(); if (read == 0) { throw new EndOfStreamException("Stream ended without reaching end of json content"); } bytes.Valid = read; 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); } }
private static unsafe void WriteToStream(Stream stream, BlittableJsonDocumentBuilder builder, byte[] buffer) { using (var reader = builder.CreateReader()) { fixed(byte *pBuffer = buffer) { var bytes = reader.BasePointer; var remainingSize = reader.Size; while (remainingSize > 0) { var size = Math.Min(remainingSize, buffer.Length); Memory.Copy(pBuffer, bytes + (reader.Size - remainingSize), size); remainingSize -= size; stream.Write(buffer, 0, size); } } } }
public async ValueTask<bool> MoveNextAsync() { if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer, _token).ConfigureAwait(false) == false) UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); if (_state.CurrentTokenType == JsonParserToken.EndArray) { _done = true; _current = null; return false; } using (var builder = new BlittableJsonDocumentBuilder(_context, BlittableJsonDocumentBuilder.UsageMode.None, "readArray/singleResult", _parser, _state)) { await UnmanagedJsonParserHelper.ReadObjectAsync(builder, _peepingTomStream, _parser, _buffer, _token).ConfigureAwait(false); _current = builder.CreateReader(); return true; } }
public async Task InitializeAsync() { AssertNotSync(); try { _initialized = true; _state = new JsonParserState(); _parser = new UnmanagedJsonParser(_session.Context, _state, "stream contents"); _builder = new BlittableJsonDocumentBuilder(_builderContext, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "readArray/singleResult", _parser, _state); _returnBuffer = _session.Context.GetMemoryBuffer(out _buffer); if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer, _token).ConfigureAwait(false) == false) UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); if (_state.CurrentTokenType != JsonParserToken.StartObject) UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); if (_isQueryStream) HandleStreamQueryStats(_builderContext, _response, _parser, _state, _buffer, _streamQueryStatistics); var property = UnmanagedJsonParserHelper.ReadString(_builderContext, _peepingTomStream, _parser, _state, _buffer); if (string.Equals(property, "Results") == false) UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer, _token).ConfigureAwait(false) == false) UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); if (_state.CurrentTokenType != JsonParserToken.StartArray) UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } catch { await DisposeAsync().ConfigureAwait(false); throw; } }
public bool MoveNext() { AssertInitialized(); CheckIfContextNeedsToBeRenewed(); if (UnmanagedJsonParserHelper.Read(_peepingTomStream, _parser, _state, _buffer) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } if (_state.CurrentTokenType == JsonParserToken.EndArray) { if (UnmanagedJsonParserHelper.Read(_peepingTomStream, _parser, _state, _buffer) == false) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } if (_state.CurrentTokenType != JsonParserToken.EndObject) { UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream); } return(false); } using (var builder = new BlittableJsonDocumentBuilder(_session.Context, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "readArray/singleResult", _parser, _state)) { if (_cachedItemsRenew == false) { _cachedItemsRenew = builder.NeedResetPropertiesCache(); } UnmanagedJsonParserHelper.ReadObject(builder, _peepingTomStream, _parser, _buffer); Current = builder.CreateReader(); return(true); } }
public async Task <BlittableJsonReaderObject> TryReadFromWebSocket( JsonOperationContext context, RavenClientWebSocket webSocket, string debugTag, CancellationToken cancellationToken) { var jsonParserState = new JsonParserState(); JsonOperationContext.ManagedPinnedBuffer bytes; using (context.GetManagedBuffer(out bytes)) using (var parser = new UnmanagedJsonParser(context, jsonParserState, debugTag)) { var writer = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, debugTag, parser, jsonParserState); writer.ReadObjectDocument(); var result = await webSocket.ReceiveAsync(bytes.Buffer, cancellationToken).ConfigureAwait(false); parser.SetBuffer(bytes, result.Count); while (writer.Read() == false) { // we got incomplete json response. // This might happen if we close the connection but still server sends something if (result.CloseStatus != null) { return(null); } result = await webSocket.ReceiveAsync(bytes.Buffer, cancellationToken).ConfigureAwait(false); parser.SetBuffer(bytes, result.Count); } writer.FinalizeDocument(); return(writer.CreateReader()); } }
private async Task ProcessChanges() { using (_requestExecutor.ContextPool.AllocateOperationContext(out var context)) { while (_cts.IsCancellationRequested == false) { context.Reset(); context.Renew(); var state = new JsonParserState(); using (var stream = new WebSocketStream(_client, _cts.Token)) using (context.GetMemoryBuffer(out JsonOperationContext.MemoryBuffer buffer)) using (var parser = new UnmanagedJsonParser(context, state, "changes/receive")) using (var builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, "readArray/singleResult", parser, state)) using (var peepingTomStream = new PeepingTomStream(stream, context)) { if (await UnmanagedJsonParserHelper.ReadAsync(peepingTomStream, parser, state, buffer).ConfigureAwait(false) == false) { continue; } if (state.CurrentTokenType != JsonParserToken.StartArray) { continue; } while (true) { builder.Reset(); builder.Renew("changes/receive", BlittableJsonDocumentBuilder.UsageMode.None); if (await UnmanagedJsonParserHelper.ReadAsync(peepingTomStream, parser, state, buffer).ConfigureAwait(false) == false) { continue; } if (state.CurrentTokenType == JsonParserToken.EndArray) { break; } await UnmanagedJsonParserHelper.ReadObjectAsync(builder, peepingTomStream, parser, buffer).ConfigureAwait(false); using (var json = builder.CreateReader()) { try { if (json.TryGet(nameof(TopologyChange), out bool supports) && supports) { GetOrAddConnectionState("Topology", "watch-topology-change", "", ""); await _requestExecutor.UpdateTopologyAsync(new RequestExecutor.UpdateTopologyParameters(_serverNode) { TimeoutInMs = 0, ForceUpdate = true, DebugTag = "watch-topology-change" }).ConfigureAwait(false); continue; } if (json.TryGet("Type", out string type) == false) { continue; } switch (type) { case "Error": json.TryGet("Exception", out string exceptionAsString); NotifyAboutError(new Exception(exceptionAsString)); break; case "Confirm": if (json.TryGet("CommandId", out int commandId) && _confirmations.TryRemove(commandId, out var tcs)) { tcs.TrySetResult(null); } break; default: json.TryGet("Value", out BlittableJsonReaderObject value); NotifySubscribers(type, value, _counters.ForceEnumerateInThreadSafeManner().Select(x => x.Value).ToList()); break; } } catch (Exception e) { NotifyAboutError(e); throw new ChangeProcessingException(e); } } } } } } }
public void JsonDeserialize_WhenHasBlittableObjectPropertyAndWriteAndReadFromStream_ShouldResultInCommandWithTheProperty() { using (Server.ServerStore.ContextPool.AllocateOperationContext(out JsonOperationContext context)) { var jsonSerializer = new JsonSerializer { ContractResolver = new DefaultRavenContractResolver(DocumentConventions.Default.Serialization), }; jsonSerializer.Converters.Add(BlittableJsonConverter.Instance); var data = new { SomeProperty = "SomeValue" }; var expected = DocumentConventions.Default.Serialization.DefaultConverter.ToBlittable(data, context); var command = new Command { BlittableObject = expected }; //Serialize BlittableJsonReaderObject toStream; using (var writer = new BlittableJsonWriter(context)) { jsonSerializer.Serialize(writer, command); writer.FinalizeDocument(); toStream = writer.CreateReader(); } //Simulates copying to file and loading BlittableJsonReaderObject fromStream; using (Stream stream = new MemoryStream()) { //Pass to stream using (var textWriter = new BlittableJsonTextWriter(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)) { UnmanagedJsonParserHelper.Read(peepingTomStream, parser, state, buffer); UnmanagedJsonParserHelper.ReadObject(builder, peepingTomStream, parser, buffer); fromStream = builder.CreateReader(); } } //Deserialize BlittableJsonReaderObject actual; using (var reader = new BlittableJsonReader(context)) { reader.Initialize(fromStream); var deserialized = jsonSerializer.Deserialize <Command>(reader); actual = deserialized.BlittableObject; } Assert.Equal(expected, actual); } }