public UserClaimsAdded <TKey> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { var claimFormatter = formatterResolver.GetFormatter <Claim>(); var keyFormatter = formatterResolver.GetFormatter <TKey>(); var startOffset = offset; var k = keyFormatter.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; var array = new Claim[len]; for (int i = 0; i < array.Length; i++) { array[i] = claimFormatter.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; } readSize = offset - startOffset; return(new UserClaimsAdded <TKey>(k, array)); }
public ValueTuple <T1> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { throw new InvalidOperationException("Data is Nil, ValueTuple can not be null."); } else { var startOffset = offset; var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); if (count != 1) { throw new InvalidOperationException("Invalid ValueTuple count"); } offset += readSize; var item1 = formatterResolver.GetFormatterWithVerify <T1>().Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; readSize = offset - startOffset; return(new ValueTuple <T1>(item1)); } }
public System.Numerics.Complex Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { var startOffset = offset; var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (count != 2) { throw new InvalidOperationException("Invalid Complex format."); } var real = MessagePackBinary.ReadDouble(bytes, offset, out readSize); offset += readSize; var imaginary = MessagePackBinary.ReadDouble(bytes, offset, out readSize); offset += readSize; readSize = offset - startOffset; return(new System.Numerics.Complex(real, imaginary)); }
public KeyValuePair <TKey, TValue> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { var startOffset = offset; var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (count != 2) { throw new InvalidOperationException("Invalid KeyValuePair format."); } var key = formatterResolver.GetFormatterWithVerify <TKey>().Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; var value = formatterResolver.GetFormatterWithVerify <TValue>().Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; readSize = offset - startOffset; return(new KeyValuePair <TKey, TValue>(key, value)); }
public OffsetDateTime Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { var startOffset = offset; var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (count != 2) { throw new InvalidOperationException("Invalid array count"); } var dt = LocalDateTimeAsDateTimeMessagePackFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; var off = OffsetMessagePackFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; readSize = offset - startOffset; return(new OffsetDateTime(dt, off)); }
public UInt32[] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } else { var startOffset = offset; var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; var array = new UInt32[len]; for (int i = 0; i < array.Length; i++) { array[i] = MessagePackBinary.ReadUInt32(bytes, offset, out readSize); offset += readSize; } readSize = offset - startOffset; return(array); } }
public T[] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return null; } else { var startOffset = offset; var formatter = formatterResolver.GetFormatterWithVerify<T>(); var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; var array = new T[len]; for (int i = 0; i < array.Length; i++) { array[i] = formatter.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; } readSize = offset - startOffset; return array; } }
public Tuple <T1> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } else { var startOffset = offset; var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); if (count != 1) { ThrowHelper.ThrowInvalidOperationException_Tuple_Count(); } offset += readSize; var item1 = formatterResolver.GetFormatterWithVerify <T1>().Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; readSize = offset - startOffset; return(new Tuple <T1>(item1)); } }
public string[] Deserialize(byte[] bytes, int offset, IFormatterResolver typeResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } var startOffset = offset; var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; var array = new string[len]; for (var i = 0; i < array.Length; i++) { array[i] = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; } readSize = offset - startOffset; return(array); }
public DateTime[] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } else { var startOffset = offset; var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; var array = new DateTime[len]; for (int i = 0; i < array.Length; i++) { var dateData = MessagePackBinary.ReadInt64(bytes, offset, out readSize); array[i] = DateTime.FromBinary(dateData); offset += readSize; } readSize = offset - startOffset; return(array); } }
public IList Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return default(IList); } var formatter = formatterResolver.GetFormatterWithVerify<object>(); var startOffset = offset; var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; var list = new object[count]; for (int i = 0; i < count; i++) { list[i] = formatter.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; } readSize = offset - startOffset; return list; }
public List <T> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } else { var startOffset = offset; var formatter = formatterResolver.GetFormatterWithVerify <T>(); var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; var list = new List <T>(len); for (int i = 0; i < len; i++) { list.Add(formatter.Deserialize(bytes, offset, formatterResolver, out readSize)); offset += readSize; } readSize = offset - startOffset; return(list); } }
public DateTimeOffset Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { var startOffset = offset; var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (count != 2) { throw new InvalidOperationException("Invalid DateTimeOffset format."); } var utc = MessagePackBinary.ReadDateTime(bytes, offset, out readSize); offset += readSize; var dtOffsetMinutes = MessagePackBinary.ReadInt16(bytes, offset, out readSize); offset += readSize; readSize = offset - startOffset; return(new DateTimeOffset(utc.Ticks, TimeSpan.FromMinutes(dtOffsetMinutes))); }
/// <inheritdoc /> public HttpRequestMessage Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } int startOffset = offset; int count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (count != 5) { throw new InvalidOperationException("Request format invalid."); } // RequestPart.Version: string versionStr = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; if (!Version.TryParse(versionStr, out Version version)) { throw new InvalidOperationException($"Request version '{versionStr}' in invalid format!"); } // RequestPart.UriScheme: string uriStr = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; if (!Uri.TryCreate(uriStr, UriKind.Absolute, out Uri uri)) { throw new InvalidOperationException($"Request Uri '{uri}' could not be parsed"); } // RequestPart.Method: HttpMethod method = HttpMethodFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; // Create request so we can add headers and content HttpRequestMessage request = new HttpRequestMessage(method, uri) { Version = version }; // RequestPart.Headers: int headersCount = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize); offset += readSize; if (headersCount > 0) { while (headersCount-- > 0) { string key = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; int valuesCount = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; // Note, we can't have an empty array, and if we tried adding one it would be ignored anyway // therefore it's safe to just start looping and call add for each entry. while (valuesCount-- > 0) { string headerValue = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; request.Headers.TryAddWithoutValidation(key, headerValue); } } } // RequestPart.Content: #pragma warning disable DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation. request.Content = HttpContentFormatter.Deserialize(bytes, offset, out readSize); #pragma warning restore DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation. offset += readSize; readSize = offset - startOffset; return(request); }
public T[,,,] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } else { var startOffset = offset; var formatter = formatterResolver.GetFormatterWithVerify <T>(); var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (len != ArrayLength) { throw new InvalidOperationException("Invalid T[,,,] format"); } var iLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var jLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var kLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var lLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var maxLen = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; var array = new T[iLength, jLength, kLength, lLength]; var i = 0; var j = 0; var k = 0; var l = -1; using (MessagePackSecurity.DepthStep()) { for (int loop = 0; loop < maxLen; loop++) { if (l < lLength - 1) { l++; } else if (k < kLength - 1) { l = 0; k++; } else if (j < jLength - 1) { l = 0; k = 0; j++; } else { l = 0; k = 0; j = 0; i++; } array[i, j, k, l] = formatter.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; } } readSize = offset - startOffset; return(array); } }
/// <summary> /// Deserializes the content into the specified response. /// </summary> /// <param name="bytes">The bytes.</param> /// <param name="offset">The offset.</param> /// <param name="readSize">Size of the read.</param> /// <returns></returns> /// <exception cref="InvalidOperationException">Content format invalid.</exception> public static HttpContent Deserialize(byte[] bytes, int offset, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } int startOffset = offset; int count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (count != 3) { throw new InvalidOperationException("Content format invalid."); } // Type byte typeByte = MessagePackBinary.ReadByte(bytes, offset, out readSize); offset += readSize; // Headers Dictionary <string, string[]> headers = new Dictionary <string, string[]>(StringComparer.OrdinalIgnoreCase); if (MessagePackBinary.IsNil(bytes, offset)) { readSize++; } else { int headersCount = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize); offset += readSize; if (headersCount > 0) { while (headersCount-- > 0) { string key = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; int valuesCount = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; string[] values = new string[valuesCount]; // Note, we can't have an empty array, and if we tried adding one it would be ignored anyway // therefore it's safe to just start looping and call add for each entry. for (int i = 0; i < valuesCount; i++) { string headerValue = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; values[i] = headerValue; } headers[key] = values; } } } // Get data byte[] data = MessagePackBinary.ReadBytes(bytes, offset, out readSize); HttpContent content; switch (typeByte) { // StreamContent case 1: #pragma warning disable DF0000 // Marks undisposed anonymous objects from object creations. content = new StreamContent(new MemoryStream(data)); #pragma warning restore DF0000 // Marks undisposed anonymous objects from object creations. break; /* * TODO * case 2: * // See https://github.com/dotnet/corefx/blob/master/src/System.Net.Http/src/System/Net/Http/FormUrlEncodedContent.cs * string encoded = Encoding.UTF8.GetString(data).Replace("+", "%20"); * List<KeyValuePair<string, string>> nvc = new List<KeyValuePair<string, string>>(); * int start = 0; * do * { * * } while () * * * break; */ case 3: // See https://github.com/dotnet/corefx/blob/master/src/System.Net.Http/src/System/Net/Http/StringContent.cs // Get encoding from headers if possible Encoding encoding; string charSet; if (headers.TryGetValue("content-type", out string[] ctValues) &&
/// <inheritdoc /> public HttpResponseMessage Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } int startOffset = offset; int count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (count != 5) { throw new InvalidOperationException("Response format invalid."); } // Version string versionStr = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; if (!Version.TryParse(versionStr, out Version version)) { throw new InvalidOperationException($"Response version '{versionStr}' in invalid format!"); } // Status Code HttpStatusCode statusCode = (HttpStatusCode)MessagePackBinary.ReadUInt16(bytes, offset, out readSize); offset += readSize; // ReasonPhrase string reasonPhrase = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; // Create response so we can start updating it's headers HttpResponseMessage response = new HttpResponseMessage(statusCode) { Version = version, ReasonPhrase = reasonPhrase }; // Headers int headersCount = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize); offset += readSize; if (headersCount > 0) { while (headersCount-- > 0) { string key = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; int valuesCount = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; // Note, we can't have an empty array, and if we tried adding one it would be ignored anyway // therefore it's safe to just start looping and call add for each entry. while (valuesCount-- > 0) { string headerValue = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; response.Headers.TryAddWithoutValidation(key, headerValue); } } } // Content #pragma warning disable DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation. response.Content = HttpContentFormatter.Deserialize(bytes, offset, out readSize); #pragma warning restore DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation. readSize = offset - startOffset; return(response); }
public Period Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } var startOffset = offset; var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (count != 10) { throw new InvalidOperationException("Invalid array count"); } var years = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var months = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var weeks = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var days = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var hours = MessagePackBinary.ReadInt64(bytes, offset, out readSize); offset += readSize; var minutes = MessagePackBinary.ReadInt64(bytes, offset, out readSize); offset += readSize; var seconds = MessagePackBinary.ReadInt64(bytes, offset, out readSize); offset += readSize; var milliseconds = MessagePackBinary.ReadInt64(bytes, offset, out readSize); offset += readSize; var ticks = MessagePackBinary.ReadInt64(bytes, offset, out readSize); offset += readSize; var nano = MessagePackBinary.ReadInt64(bytes, offset, out readSize); offset += readSize; readSize = offset - startOffset; return(new PeriodBuilder() { Years = years, Months = months, Weeks = weeks, Days = days, Hours = hours, Minutes = minutes, Seconds = seconds, Milliseconds = milliseconds, Ticks = ticks, Nanoseconds = nano, }.Build()); }
async Task StartSubscribe() { var syncContext = SynchronizationContext.Current; // capture SynchronizationContext. var reader = connection.RawStreamingCall.ResponseStream; try { while (await reader.MoveNext(cts.Token).ConfigureAwait(false)) // avoid Post to SyncContext(it losts one-frame per operation) { try { var data = reader.Current; // MessageFormat: // broadcast: [methodId, [argument]] // response: [messageId, methodId, response] // error-response: [messageId, statusCode, detail, StringMessage] var readSize = 0; var offset = 0; var arrayLength = MessagePackBinary.ReadArrayHeader(data, offset, out readSize); offset += readSize; if (arrayLength == 3) { var messageId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; object future; if (responseFutures.TryRemove(messageId, out future)) { var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; try { OnResponseEvent(methodId, future, new ArraySegment <byte>(data, offset, data.Length - offset)); } catch (Exception ex) { if (!(future as ITaskCompletion).TrySetException(ex)) { throw; } } } } else if (arrayLength == 4) { var messageId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; object future; if (responseFutures.TryRemove(messageId, out future)) { var statusCode = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; var detail = MessagePackBinary.ReadString(data, offset, out readSize); offset += readSize; var error = LZ4MessagePackSerializer.Deserialize <string>(new ArraySegment <byte>(data, offset, data.Length - offset)); (future as ITaskCompletion).TrySetException(new RpcException(new Status((StatusCode)statusCode, detail), error)); } } else { var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; if (syncContext != null) { var tuple = Tuple.Create(methodId, data, offset, data.Length - offset); syncContext.Post(state => { var t = (Tuple <int, byte[], int, int>)state; OnBroadcastEvent(t.Item1, new ArraySegment <byte>(t.Item2, t.Item3, t.Item4)); }, tuple); } else { OnBroadcastEvent(methodId, new ArraySegment <byte>(data, offset, data.Length - offset)); } } } catch (Exception ex) { const string msg = "Error on consume received message, but keep subscribe."; // log post on main thread. if (syncContext != null) { syncContext.Post(state => logger.Error((Exception)state, msg), ex); } else { logger.Error(ex, msg); } } } } catch (Exception ex) { if (ex is OperationCanceledException) { return; } const string msg = "Error on subscribing message."; // log post on main thread. if (syncContext != null) { syncContext.Post(state => logger.Error((Exception)state, msg), ex); } else { logger.Error(ex, msg); } } finally { try { // set syncContext before await if (syncContext != null && SynchronizationContext.Current == null) { SynchronizationContext.SetSynchronizationContext(syncContext); } await DisposeAsyncCore(false); } finally { waitForDisconnect.TrySetResult(null); } } }
async Task HandleMessageAsync() { var ct = Context.CallContext.CancellationToken; var reader = Context.RequestStream; var writer = Context.ResponseStream; var handlers = StreamingHubHandlerRepository.GetHandlers(Context.MethodHandler); // Main loop of StreamingHub. // Be careful to allocation and performance. while (await reader.MoveNext(ct)) { var data = reader.Current; var length = MessagePackBinary.ReadArrayHeader(data, 0, out var readSize); var offset = readSize; if (length == 2) { // void: [methodId, [argument]] var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; if (handlers.TryGetValue(methodId, out var handler)) { var context = new StreamingHubContext() // create per invoke. { AsyncWriterLock = Context.AsyncWriterLock, FormatterResolver = handler.resolver, HubInstance = this, ServiceContext = Context, Request = new ArraySegment <byte>(data, offset, data.Length - offset), Path = handler.ToString(), MethodId = handler.MethodId, MessageId = -1, Timestamp = DateTime.UtcNow }; var isErrorOrInterrupted = false; Context.MethodHandler.logger.BeginInvokeHubMethod(context, context.Request, handler.RequestType); try { await handler.MethodBody.Invoke(context); } catch (Exception ex) { isErrorOrInterrupted = true; LogError(ex, context); } finally { Context.MethodHandler.logger.EndInvokeHubMethod(context, context.responseSize, context.responseType, (DateTime.UtcNow - context.Timestamp).TotalMilliseconds, isErrorOrInterrupted); } } else { throw new InvalidOperationException("Handler not found in received methodId, methodId:" + methodId); } } else if (length == 3) { // T: [messageId, methodId, [argument]] var messageId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; if (handlers.TryGetValue(methodId, out var handler)) { var context = new StreamingHubContext() // create per invoke. { AsyncWriterLock = Context.AsyncWriterLock, FormatterResolver = handler.resolver, HubInstance = this, ServiceContext = Context, Request = new ArraySegment <byte>(data, offset, data.Length - offset), Path = handler.ToString(), MethodId = handler.MethodId, MessageId = messageId, Timestamp = DateTime.UtcNow }; var isErrorOrInterrupted = false; Context.MethodHandler.logger.BeginInvokeHubMethod(context, context.Request, handler.RequestType); try { await handler.MethodBody.Invoke(context); } catch (ReturnStatusException ex) { await context.WriteErrorMessage((int)ex.StatusCode, ex.Detail, null, false); } catch (Exception ex) { LogError(ex, context); await context.WriteErrorMessage((int)StatusCode.Internal, "Erorr on " + handler.ToString(), ex, Context.MethodHandler.isReturnExceptionStackTraceInErrorDetail); } finally { Context.MethodHandler.logger.EndInvokeHubMethod(context, context.responseSize, context.responseType, (DateTime.UtcNow - context.Timestamp).TotalMilliseconds, isErrorOrInterrupted); } } else { throw new InvalidOperationException("Handler not found in received methodId, methodId:" + methodId); } } else { throw new InvalidOperationException("Invalid data format."); } } }
public UserCreated <TKey, TUser> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { var keyFormatter = formatterResolver.GetFormatter <TKey>(); var claimFormatter = formatterResolver.GetFormatter <Claim>(); var startOffset = offset; var key = keyFormatter.Deserialize(bytes, offset, formatterResolver, out readSize); var usr = (TUser)Activator.CreateInstance(typeof(TUser), key); offset += readSize; usr.UserName = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; usr.NormalizedUserName = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; usr.Email = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; usr.NormalizedEmail = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; usr.EmailConfirmed = MessagePackBinary.ReadBoolean(bytes, offset, out readSize); offset += readSize; usr.PasswordHash = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; usr.SecurityStamp = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; usr.PhoneNumber = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; usr.PhoneNumberConfirmed = MessagePackBinary.ReadBoolean(bytes, offset, out readSize); offset += readSize; usr.TwoFactorEnabled = MessagePackBinary.ReadBoolean(bytes, offset, out readSize); offset += readSize; usr.LockoutEnd = null; if (MessagePackBinary.IsNil(bytes, offset)) { offset++; } else { usr.LockoutEnd = MessagePackBinary.ReadDateTime(bytes, offset, out readSize); offset += readSize; } usr.LockoutEnabled = MessagePackBinary.ReadBoolean(bytes, offset, out readSize); offset += readSize; usr.AccessFailedCount = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; usr.Claims = null; if (MessagePackBinary.IsNil(bytes, offset)) { offset++; } else { var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; usr.Claims = new List <Claim>(len); for (int i = 0; i < len; i++) { var claim = claimFormatter.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; usr.Claims.Add(claim); } } usr.Logins = null; if (MessagePackBinary.IsNil(bytes, offset)) { offset++; } else { var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; usr.Logins = new List <ImmutableUserLoginInfo>(len); for (int i = 0; i < len; i++) { var loginProvider = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; var providerKey = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; var displayName = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; usr.Logins.Add(new ImmutableUserLoginInfo(loginProvider, providerKey, displayName)); } } usr.Tokens = null; if (MessagePackBinary.IsNil(bytes, offset)) { offset++; } else { var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; usr.Tokens = new List <ImmutableIdentityUserToken>(len); for (int i = 0; i < len; i++) { var loginProvider = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; var name = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; var value = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; usr.Tokens.Add(new ImmutableIdentityUserToken(loginProvider, name, value)); } } readSize = offset - startOffset; return(new UserCreated <TKey, TUser>(usr)); }
/// <summary> /// Open the database. /// </summary> public static Database Open(byte[] bytes) { var offset = 0; int readSize; var memoryCount = MessagePackBinary.ReadArrayHeader(bytes, 0, out readSize); offset += readSize; var memories = new KeyValuePair <string, IInternalMemory> [memoryCount]; for (int i = 0; i < memoryCount; i++) { var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (len != 2) { throw new InvalidOperationException("Invalid MsgPack Binary of Database."); } var keyName = MessagePackBinary.ReadString(bytes, offset, out readSize); offset += readSize; // is LZ4 or plain msgpack? byte[] rawData; var type = MessagePackBinary.GetMessagePackType(bytes, offset); if (type == MessagePackType.Extension) { var extensionOffset = offset; var ext = MessagePackBinary.ReadExtensionFormatHeader(bytes, offset, out readSize); if (ext.TypeCode == LZ4MessagePackSerializer.ExtensionTypeCode) { offset += readSize; offset += (int)ext.Length; rawData = new byte[offset - extensionOffset]; Buffer.BlockCopy(bytes, extensionOffset, rawData, 0, rawData.Length); goto END; } } { var beginOffset = offset; var arrayLen = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; for (int j = 0; j < arrayLen; j++) { offset += MessagePackBinary.ReadNextBlock(bytes, offset); } readSize = offset - beginOffset; rawData = new byte[readSize]; Buffer.BlockCopy(bytes, beginOffset, rawData, 0, readSize); } END: var memory = new InternalRawMemory(rawData); memories[i] = new KeyValuePair <string, IInternalMemory>(keyName, memory); } return(new Database(memories)); }
public JsonRpcRequest?Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } var startOffset = offset; int singleReadSize; if (MessagePackBinary.ReadArrayHeader(bytes, offset, out singleReadSize) != 4) { throw new InvalidOperationException("Invalid JsonRpcMessage format."); } offset += singleReadSize; var version = MessagePackBinary.ReadString(bytes, offset, out singleReadSize); offset += singleReadSize; var id = TypelessFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out singleReadSize); offset += singleReadSize; var method = MessagePackBinary.ReadString(bytes, offset, out singleReadSize); offset += singleReadSize; object?arguments; switch (MessagePackBinary.GetMessagePackType(bytes, offset)) { case MessagePackType.Nil: { arguments = null; offset++; break; } case MessagePackType.Array: { var length = MessagePackBinary.ReadArrayHeader(bytes, offset, out singleReadSize); offset += singleReadSize; var array = new object[length]; for (var i = 0; i < length; i++) { array[i] = TypelessFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out singleReadSize); offset += singleReadSize; } arguments = array; break; } case MessagePackType.Map: { var length = MessagePackBinary.ReadMapHeader(bytes, offset, out singleReadSize); offset += singleReadSize; var map = new Dictionary <string, object>(length); for (var i = 0; i < length; i++) { var key = MessagePackBinary.ReadString(bytes, offset, out singleReadSize); offset += singleReadSize; var value = TypelessFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out singleReadSize); offset += singleReadSize; map.Add(key, value); } arguments = map; break; } default: throw new InvalidOperationException(string.Format("Invalid code : {0}", bytes[offset])); } readSize = offset - startOffset; return(new JsonRpcRequest() { Version = version, Id = id, Method = method, Arguments = arguments, }); }
public object Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { var type = MessagePackBinary.GetMessagePackType(bytes, offset); switch (type) { case MessagePackType.Integer: var code = bytes[offset]; if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt) { return(MessagePackBinary.ReadSByte(bytes, offset, out readSize)); } else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt) { return(MessagePackBinary.ReadByte(bytes, offset, out readSize)); } else if (code == MessagePackCode.Int8) { return(MessagePackBinary.ReadSByte(bytes, offset, out readSize)); } else if (code == MessagePackCode.Int16) { return(MessagePackBinary.ReadInt16(bytes, offset, out readSize)); } else if (code == MessagePackCode.Int32) { return(MessagePackBinary.ReadInt32(bytes, offset, out readSize)); } else if (code == MessagePackCode.Int64) { return(MessagePackBinary.ReadInt64(bytes, offset, out readSize)); } else if (code == MessagePackCode.UInt8) { return(MessagePackBinary.ReadByte(bytes, offset, out readSize)); } else if (code == MessagePackCode.UInt16) { return(MessagePackBinary.ReadUInt16(bytes, offset, out readSize)); } else if (code == MessagePackCode.UInt32) { return(MessagePackBinary.ReadUInt32(bytes, offset, out readSize)); } else if (code == MessagePackCode.UInt64) { return(MessagePackBinary.ReadUInt64(bytes, offset, out readSize)); } throw new InvalidOperationException("Invalid primitive bytes."); case MessagePackType.Boolean: return(MessagePackBinary.ReadBoolean(bytes, offset, out readSize)); case MessagePackType.Float: if (MessagePackCode.Float32 == bytes[offset]) { return(MessagePackBinary.ReadSingle(bytes, offset, out readSize)); } else { return(MessagePackBinary.ReadDouble(bytes, offset, out readSize)); } case MessagePackType.String: return(MessagePackBinary.ReadString(bytes, offset, out readSize)); case MessagePackType.Binary: return(MessagePackBinary.ReadBytes(bytes, offset, out readSize)); case MessagePackType.Extension: var ext = MessagePackBinary.ReadExtensionFormatHeader(bytes, offset, out readSize); if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime) { return(MessagePackBinary.ReadDateTime(bytes, offset, out readSize)); } throw new InvalidOperationException("Invalid primitive bytes."); case MessagePackType.Array: { var length = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); var startOffset = offset; offset += readSize; var objectFormatter = formatterResolver.GetFormatter <object>(); var array = new object[length]; for (int i = 0; i < length; i++) { array[i] = objectFormatter.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; } readSize = offset - startOffset; return(array); } case MessagePackType.Map: { var length = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize); var startOffset = offset; offset += readSize; var objectFormatter = formatterResolver.GetFormatter <object>(); var hash = new Dictionary <object, object>(length); for (int i = 0; i < length; i++) { var key = objectFormatter.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; var value = objectFormatter.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; hash.Add(key, value); } readSize = offset - startOffset; return(hash); } case MessagePackType.Nil: readSize = 1; return(null); default: throw new InvalidOperationException("Invalid primitive bytes."); } }
public T[,,] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { if (MessagePackBinary.IsNil(bytes, offset)) { readSize = 1; return(null); } else { var startOffset = offset; var formatter = formatterResolver.GetFormatterWithVerify <T>(); var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; if (len != ArrayLength) { ThrowHelper.ThrowInvalidOperationException_T_Format2(); } var iLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var jLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var kLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize); offset += readSize; var maxLen = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; var array = new T[iLength, jLength, kLength]; var i = 0; var j = 0; var k = -1; for (int loop = 0; loop < maxLen; loop++) { if (k < kLength - 1) { k++; } else if (j < jLength - 1) { k = 0; j++; } else { k = 0; j = 0; i++; } array[i, j, k] = formatter.Deserialize(bytes, offset, formatterResolver, out readSize); offset += readSize; } readSize = offset - startOffset; return(array); } }
public void Read() { void Check1 <T, T2>(T data, T2 result, Func <Stream, T2> streamRead) { const int CheckOffset = 10; byte[] bytes = null; var len = MessagePack.Resolvers.StandardResolver.Instance.GetFormatter <T>().Serialize(ref bytes, CheckOffset, data, MessagePack.Resolvers.StandardResolver.Instance); MessagePackBinary.FastResize(ref bytes, CheckOffset + len); var ms = new MemoryStream(bytes); ms.Position = CheckOffset; streamRead(ms).Is(result); } void Check2 <T>(T data, Func <Stream, T> streamRead) { const int CheckOffset = 10; byte[] bytes = null; var len = MessagePack.Resolvers.StandardResolver.Instance.GetFormatter <T>().Serialize(ref bytes, CheckOffset, data, MessagePack.Resolvers.StandardResolver.Instance); MessagePackBinary.FastResize(ref bytes, CheckOffset + len); var ms = new MemoryStream(bytes); ms.Position = CheckOffset; streamRead(ms).Is(data); } Check1(new[] { 1, 10, 100, 1000, 10000, short.MaxValue, int.MaxValue }, 7, x => MessagePackBinary.ReadArrayHeader(x)); Check1(new[] { 1, 10, 100, 1000, 10000, short.MaxValue, int.MaxValue }, (uint)7, x => MessagePackBinary.ReadArrayHeaderRaw(x)); Check1(Nil.Default, true, x => MessagePackBinary.IsNil((x))); Check2(true, x => MessagePackBinary.ReadBoolean(x)); Check2((byte)100, x => MessagePackBinary.ReadByte(x)); Check2(new byte[] { 1, 10, 100, 245 }, x => MessagePackBinary.ReadBytes(x)); Check2('あ', x => MessagePackBinary.ReadChar(x)); Check2(DateTime.UtcNow, x => MessagePackBinary.ReadDateTime(x)); Check2(132, x => MessagePackBinary.ReadInt16(x)); Check2(423, x => MessagePackBinary.ReadInt32(x)); Check2(64332, x => MessagePackBinary.ReadInt64(x)); Check2(Nil.Default, x => MessagePackBinary.ReadNil(x)); Check2(11, x => MessagePackBinary.ReadSByte(x)); Check2(10.31231f, x => MessagePackBinary.ReadSingle(x)); Check2("foobar", x => MessagePackBinary.ReadString(x)); Check2(124, x => MessagePackBinary.ReadUInt16(x)); Check2((uint)432, x => MessagePackBinary.ReadUInt32(x)); Check2((ulong)432, x => MessagePackBinary.ReadUInt64(x)); Check1(new Dictionary <int, int>() { { 1, 2 } }, 1, x => MessagePackBinary.ReadMapHeader(x)); Check1(new Dictionary <int, int>() { { 1, 2 } }, (uint)1, x => MessagePackBinary.ReadMapHeaderRaw(x)); { var block = new object[] { 1, new[] { 1, 10, 100 }, 100 }; var bytes = MessagePackSerializer.Serialize(block); var stream = new MemoryStream(bytes); MessagePackBinary.ReadNext(stream); // array(first) MessagePackBinary.ReadNext(stream); // int MessagePackBinary.ReadNextBlock(stream); // skip array MessagePackBinary.ReadInt32(stream).Is(100); } { var block = new object[] { 1, new Dictionary <int, int> { { 1, 10 }, { 111, 200 } }, 100 }; var bytes = MessagePackSerializer.Serialize(block); var stream = new MemoryStream(bytes); MessagePackBinary.ReadNext(stream); MessagePackBinary.ReadNext(stream); MessagePackBinary.ReadNextBlock(stream); MessagePackBinary.ReadInt32(stream).Is(100); } }
async Task StartSubscribe() { var reader = connection.RawStreamingCall.ResponseStream; try { while (await reader.MoveNext(cts.Token)) { try { var data = reader.Current; // MessageFormat: // broadcast: [methodId, [argument]] // response: [messageId, methodId, response] // error-response: [messageId, statusCode, detail, StringMessage] var readSize = 0; var offset = 0; var arrayLength = MessagePackBinary.ReadArrayHeader(data, offset, out readSize); offset += readSize; if (arrayLength == 3) { var messageId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; object future; if (responseFutures.TryRemove(messageId, out future)) { var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; try { OnResponseEvent(methodId, future, new ArraySegment <byte>(data, offset, data.Length - offset)); } catch (Exception ex) { if (!(future as ITaskCompletion).TrySetException(ex)) { throw; } } } } else if (arrayLength == 4) { var messageId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; object future; if (responseFutures.TryRemove(messageId, out future)) { var statusCode = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; var detail = MessagePackBinary.ReadString(data, offset, out readSize); offset += readSize; var error = LZ4MessagePackSerializer.Deserialize <string>(new ArraySegment <byte>(data, offset, data.Length - offset)); (future as ITaskCompletion).TrySetException(new RpcException(new Status((StatusCode)statusCode, detail), error)); } } else { var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize); offset += readSize; await OnBroadcastEvent(methodId, new ArraySegment <byte>(data, offset, data.Length - offset)); } } catch (Exception ex) { logger?.Error(ex, "Error on consume received message, but keep subscribe."); } } } catch (Exception ex) { if (ex is OperationCanceledException) { return; } logger?.Error(ex, "Error on subscribing message."); } finally { try { await DisposeAsyncCore(false); } finally { waitForDisconnect.TrySetResult(null); } } }
public DynamicArgumentTuple <T1, T2, T3, T4, T5, T6, T7, T8, T9> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { var startOffset = offset; var length = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; var item1 = default1; var item2 = default2; var item3 = default3; var item4 = default4; var item5 = default5; var item6 = default6; var item7 = default7; var item8 = default8; var item9 = default9; for (var i = 0; i < length; i++) { switch (i) { case 0: item1 = formatterResolver.GetFormatterWithVerify <T1>().Deserialize(bytes, offset, formatterResolver, out readSize); break; case 1: item2 = formatterResolver.GetFormatterWithVerify <T2>().Deserialize(bytes, offset, formatterResolver, out readSize); break; case 2: item3 = formatterResolver.GetFormatterWithVerify <T3>().Deserialize(bytes, offset, formatterResolver, out readSize); break; case 3: item4 = formatterResolver.GetFormatterWithVerify <T4>().Deserialize(bytes, offset, formatterResolver, out readSize); break; case 4: item5 = formatterResolver.GetFormatterWithVerify <T5>().Deserialize(bytes, offset, formatterResolver, out readSize); break; case 5: item6 = formatterResolver.GetFormatterWithVerify <T6>().Deserialize(bytes, offset, formatterResolver, out readSize); break; case 6: item7 = formatterResolver.GetFormatterWithVerify <T7>().Deserialize(bytes, offset, formatterResolver, out readSize); break; case 7: item8 = formatterResolver.GetFormatterWithVerify <T8>().Deserialize(bytes, offset, formatterResolver, out readSize); break; case 8: item9 = formatterResolver.GetFormatterWithVerify <T9>().Deserialize(bytes, offset, formatterResolver, out readSize); break; default: readSize = MessagePackBinary.ReadNextBlock(bytes, offset); break; } offset += readSize; } readSize = offset - startOffset; return(new DynamicArgumentTuple <T1, T2, T3, T4, T5, T6, T7, T8, T9>(item1, item2, item3, item4, item5, item6, item7, item8, item9)); }
internal static object Deserialize(ObjectSerializationInfo metaInfo, ObjectSerializationInfo.EmittableMember[] readMembers, int[] constructorParameterIndexes, AutomataDictionary mapMemberDictionary, byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize) { var startOffset = offset; object[] parameters = null; var headerType = MessagePackBinary.GetMessagePackType(bytes, offset); if (headerType == MessagePackType.Nil) { readSize = 1; return(null); } else if (headerType == MessagePackType.Array) { var arraySize = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize); offset += readSize; // ReadValues parameters = new object[arraySize]; for (int i = 0; i < arraySize; i++) { var info = readMembers[i]; if (info != null) { parameters[i] = MessagePackSerializer.NonGeneric.Deserialize(info.Type, bytes, offset, formatterResolver, out readSize); offset += readSize; } else { offset += MessagePackBinary.ReadNextBlock(bytes, offset); } } } else if (headerType == MessagePackType.Map) { var mapSize = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize); offset += readSize; // ReadValues parameters = new object[mapSize]; for (int i = 0; i < mapSize; i++) { var rawPropName = MessagePackBinary.ReadStringSegment(bytes, offset, out readSize); offset += readSize; int index; if (mapMemberDictionary.TryGetValue(rawPropName.Array, rawPropName.Offset, rawPropName.Count, out index)) { var info = readMembers[index]; parameters[index] = MessagePackSerializer.NonGeneric.Deserialize(info.Type, bytes, offset, formatterResolver, out readSize); offset += readSize; } else { offset += MessagePackBinary.ReadNextBlock(bytes, offset); } } } else { throw new InvalidOperationException("Invalid MessagePackType:" + MessagePackCode.ToFormatName(bytes[offset])); } // CreateObject object result = null; if (constructorParameterIndexes.Length == 0) { result = Activator.CreateInstance(metaInfo.Type); } else { var args = new object[constructorParameterIndexes.Length]; for (int i = 0; i < constructorParameterIndexes.Length; i++) { args[i] = parameters[constructorParameterIndexes[i]]; } result = Activator.CreateInstance(metaInfo.Type, args); } // SetMembers for (int i = 0; i < readMembers.Length; i++) { var info = readMembers[i]; if (info != null) { info.ReflectionStoreValue(result, parameters[i]); } } readSize = offset - startOffset; return(result); }