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