// MessageFormat: // broadcast: [methodId, [argument]] // response: [messageId, methodId, response] // error-response: [messageId, statusCode, detail, StringMessage] void ConsumeData(SynchronizationContext syncContext, byte[] data) { var messagePackReader = new MessagePackReader(data); var arrayLength = messagePackReader.ReadArrayHeader(); if (arrayLength == 3) { var messageId = messagePackReader.ReadInt32(); object future; if (responseFutures.TryRemove(messageId, out future)) { var methodId = messagePackReader.ReadInt32(); try { var offset = (int)messagePackReader.Consumed; var rest = new ArraySegment <byte>(data, offset, data.Length - offset); OnResponseEvent(methodId, future, rest); } catch (Exception ex) { if (!(future as ITaskCompletion).TrySetException(ex)) { throw; } } } } else if (arrayLength == 4) { var messageId = messagePackReader.ReadInt32(); object future; if (responseFutures.TryRemove(messageId, out future)) { var statusCode = messagePackReader.ReadInt32(); var detail = messagePackReader.ReadString(); var offset = (int)messagePackReader.Consumed; var rest = new ArraySegment <byte>(data, offset, data.Length - offset); var error = MessagePackSerializer.Deserialize <string>(rest, serializerOptions); var ex = default(RpcException); if (string.IsNullOrWhiteSpace(error)) { ex = new RpcException(new Status((StatusCode)statusCode, detail)); } else { ex = new RpcException(new Status((StatusCode)statusCode, detail), detail + Environment.NewLine + error); } (future as ITaskCompletion).TrySetException(ex); } } else { var methodId = messagePackReader.ReadInt32(); var offset = (int)messagePackReader.Consumed; 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)); } } }
public virtual T LoadFromAsset(TextAsset textAsset) { return(MessagePackSerializer.Deserialize <T>(textAsset.bytes)); }
public static MplsPacket FromBytes(byte[] bytes) { return(MessagePackSerializer.Deserialize <MplsPacket>(bytes)); }
T Convert <T>(T value) { return(MessagePackSerializer.Deserialize <T>(MessagePackSerializer.Serialize(value))); }
public override void OnResponse(byte[] response) { var account = MessagePackSerializer.Deserialize <Account>(response); finishListener.OnFinish(account); }
public void FromBytes(ChatRuntime rt, byte[] bytes) { MessagePackSerializer.Deserialize <Snapshot>(bytes, ifr).Update(rt); }
public TOut Deserialize <TOut>(ReadOnlyMemory <byte> input) { return(MessagePackSerializer.Deserialize <TOut>(input, _options)); }
T Convert1 <T>(T value) { return(MessagePackSerializer.Deserialize <T>(SequenceFactory.CreateSplit(MessagePackSerializer.Serialize(value), 1, 32))); }
public SwimMessage Deserialize(ReadOnlySpan <byte> buffer) { return(MessagePackSerializer.Deserialize <SwimMessage>(buffer.ToArray(), this)); }
public StaticBody(Entity entity, byte[] data) : this(entity) { List <colliderData> cols = MessagePackSerializer.Deserialize <List <colliderData> >(data); CreateColliders(cols); }
/// <summary> /// Loads an object asyncroniously. /// Handles Loading, decryption, deserialization and will invoke the given callback when done. /// </summary> /// <param name="path">Relative path to the data folder.</param> /// <param name="callback">Callback to execute when done.</param> /// <typeparam name="T">The type to serialize to.</typeparam> public void LoadObjectAsync <T>(string path, DynamicDataCallback <T> callback) where T : new() { LoadDataAsync(path, data => callback.Invoke(MessagePackSerializer.Deserialize <T>(data))); }
public static bool TryConvert(object valueToConvert, Type targetType, out object?targetValue) { if (targetType.IsInstanceOfType(valueToConvert)) { targetValue = valueToConvert; return(true); } if (targetType.IsEnum) { if (valueToConvert is string str) { try { targetValue = Enum.Parse(targetType, str, true); return(true); } catch { //Ignore } } else { try { targetValue = Enum.ToObject(targetType, valueToConvert); return(true); } catch { //Ignore } } } if (valueToConvert is string string2 && targetType == typeof(Guid)) { if (Guid.TryParse(string2, out var result)) { targetValue = result; return(true); } } try { targetValue = Convert.ChangeType(valueToConvert, targetType); return(true); } catch { //Ignore } try { targetValue = MessagePackSerializer.Deserialize(targetType, MessagePackSerializer.Serialize(valueToConvert)); return(true); } catch { //Ignore } targetValue = null; return(false); }
public void AllowPrivate() { { var p = new HasPrivate { PublicKey = 100, PublicKeyS = "foo" }; p.SetPrivate(99, "bar"); var bin = MessagePackSerializer.Serialize(p, StandardResolverAllowPrivate.Options); var json = MessagePackSerializer.ConvertToJson(bin); json.Is("[99,100,\"bar\",\"foo\"]"); HasPrivate r2 = MessagePackSerializer.Deserialize <HasPrivate>(bin, StandardResolverAllowPrivate.Options); r2.PublicKey.Is(100); r2.PublicKeyS.Is("foo"); r2.GetPrivateInt().Is(99); r2.GetPrivateStr().Is("bar"); } { var p = new HasPrivateStruct { PublicKey = 100, PublicKeyS = "foo" }; p.SetPrivate(99, "bar"); var bin = MessagePackSerializer.Serialize(p, StandardResolverAllowPrivate.Options); var json = MessagePackSerializer.ConvertToJson(bin); json.Is("[99,100,\"bar\",\"foo\"]"); HasPrivate r2 = MessagePackSerializer.Deserialize <HasPrivate>(bin, StandardResolverAllowPrivate.Options); r2.PublicKey.Is(100); r2.PublicKeyS.Is("foo"); r2.GetPrivateInt().Is(99); r2.GetPrivateStr().Is("bar"); } { var p = new HasPrivateStringKey { PublicKey = 100, PublicKeyS = "foo" }; p.SetPrivate(99, "bar"); var bin = MessagePackSerializer.Serialize(p, StandardResolverAllowPrivate.Options); var json = MessagePackSerializer.ConvertToJson(bin); json.Is("{\"PublicKey\":100,\"privateKeyS\":\"bar\",\"PublicKeyS\":\"foo\",\"privateKey\":99}"); HasPrivateStringKey r2 = MessagePackSerializer.Deserialize <HasPrivateStringKey>(bin, StandardResolverAllowPrivate.Options); r2.PublicKey.Is(100); r2.PublicKeyS.Is("foo"); r2.GetPrivateInt().Is(99); r2.GetPrivateStr().Is("bar"); } { var p = new HasPrivateContractless { PublicKey = 100, PublicKeyS = "foo" }; p.SetPrivate(99, "bar"); var bin = MessagePackSerializer.Serialize(p, ContractlessStandardResolverAllowPrivate.Options); var json = MessagePackSerializer.ConvertToJson(bin); json.Is("{\"PublicKey\":100,\"privateKeyS\":\"bar\",\"PublicKeyS\":\"foo\",\"privateKey\":99}"); HasPrivateContractless r2 = MessagePackSerializer.Deserialize <HasPrivateContractless>(bin, ContractlessStandardResolverAllowPrivate.Options); r2.PublicKey.Is(100); r2.PublicKeyS.Is("foo"); r2.GetPrivateInt().Is(99); r2.GetPrivateStr().Is("bar"); } }
public void Union() { { var data = new MySubUnion1 { One = 23 }; var data2 = new MySubUnion1 { One = 23 }; var unionData1 = MessagePackSerializer.Serialize <IUnionChecker>(data, MsgPackUnsafeDefaultResolver.Options); var unionData2 = MessagePackSerializer.Serialize <IUnionChecker2>(data2, MsgPackUnsafeDefaultResolver.Options); var reData1 = MessagePackSerializer.Deserialize <IUnionChecker>(unionData1, MsgPackUnsafeDefaultResolver.Options); var reData2 = MessagePackSerializer.Deserialize <IUnionChecker>(unionData1, MsgPackUnsafeDefaultResolver.Options); reData1.IsInstanceOf <IUnionChecker>(); reData2.IsInstanceOf <IUnionChecker2>(); var null1 = MessagePackSerializer.Serialize <IUnionChecker>(null, MsgPackUnsafeDefaultResolver.Options); var null2 = MessagePackSerializer.Serialize <IUnionChecker2>(null, MsgPackUnsafeDefaultResolver.Options); MessagePackSerializer.Deserialize <IUnionChecker>(null1, MsgPackUnsafeDefaultResolver.Options).IsNull(); MessagePackSerializer.Deserialize <IUnionChecker2>(null1, MsgPackUnsafeDefaultResolver.Options).IsNull(); var hoge = MessagePackSerializer.Serialize <IIVersioningUnion>(new VersioningUnion { FV = 0 }, MsgPackUnsafeDefaultResolver.Options); MessagePackSerializer.Deserialize <IUnionChecker>(hoge, MsgPackUnsafeDefaultResolver.Options).IsNull(); } { var data = new MySubUnion2 { Two = 23 }; var data2 = new MySubUnion2 { Two = 23 }; var unionData1 = MessagePackSerializer.Serialize <IUnionChecker>(data, MsgPackUnsafeDefaultResolver.Options); var unionData2 = MessagePackSerializer.Serialize <IUnionChecker2>(data2, MsgPackUnsafeDefaultResolver.Options); var reData1 = MessagePackSerializer.Deserialize <IUnionChecker>(unionData1, MsgPackUnsafeDefaultResolver.Options); var reData2 = MessagePackSerializer.Deserialize <IUnionChecker>(unionData1, MsgPackUnsafeDefaultResolver.Options); reData1.IsInstanceOf <IUnionChecker>(); reData2.IsInstanceOf <IUnionChecker2>(); var null1 = MessagePackSerializer.Serialize <IUnionChecker>(null, MsgPackUnsafeDefaultResolver.Options); var null2 = MessagePackSerializer.Serialize <IUnionChecker2>(null, MsgPackUnsafeDefaultResolver.Options); MessagePackSerializer.Deserialize <IUnionChecker>(null1, MsgPackUnsafeDefaultResolver.Options).IsNull(); MessagePackSerializer.Deserialize <IUnionChecker2>(null1, MsgPackUnsafeDefaultResolver.Options).IsNull(); var hoge = MessagePackSerializer.Serialize <IIVersioningUnion>(new VersioningUnion { FV = 0 }, MsgPackUnsafeDefaultResolver.Options); MessagePackSerializer.Deserialize <IUnionChecker>(hoge, MsgPackUnsafeDefaultResolver.Options).IsNull(); } }
public static void SceneInfoImportHook(string path, BinaryReader br, Version version) { //Reading useless data br.ReadInt32(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadInt32(); br.ReadBoolean(); br.ReadInt32(); if (version.CompareTo(new Version(0, 0, 2)) >= 0) { br.ReadSingle(); } if (version.CompareTo(new Version(0, 0, 1)) <= 0) { br.ReadBoolean(); br.ReadSingle(); br.ReadString(); } if (version.CompareTo(new Version(0, 0, 2)) >= 0) { br.ReadBoolean(); br.ReadString(); br.ReadSingle(); } br.ReadBoolean(); br.ReadSingle(); br.ReadSingle(); if (version.CompareTo(new Version(0, 0, 2)) >= 0) { br.ReadSingle(); } if (version.CompareTo(new Version(0, 0, 1)) <= 0) { br.ReadBoolean(); } br.ReadBoolean(); br.ReadSingle(); br.ReadSingle(); br.ReadBoolean(); if (version.CompareTo(new Version(0, 0, 1)) <= 0) { br.ReadSingle(); } br.ReadBoolean(); if (version.CompareTo(new Version(0, 0, 2)) >= 0) { br.ReadString(); br.ReadSingle(); br.ReadSingle(); } br.ReadBoolean(); if (version.CompareTo(new Version(0, 0, 2)) >= 0) { br.ReadString(); br.ReadString(); } if (version.CompareTo(new Version(0, 0, 4)) >= 0) { br.ReadInt32(); } if (version.CompareTo(new Version(0, 0, 2)) >= 0) { br.ReadBoolean(); } if (version.CompareTo(new Version(0, 0, 4)) >= 0) { br.ReadBoolean(); br.ReadBoolean(); br.ReadSingle(); br.ReadString(); } if (version.CompareTo(new Version(0, 0, 5)) >= 0) { br.ReadSingle(); br.ReadInt32(); br.ReadSingle(); } int num = br.ReadInt32(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); if (num == 1) { br.ReadSingle(); } else { br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); } br.ReadSingle(); for (int j = 0; j < 10; j++) { num = br.ReadInt32(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); if (num == 1) { br.ReadSingle(); } else { br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); } br.ReadSingle(); } br.ReadString(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadBoolean(); br.ReadString(); br.ReadSingle(); br.ReadSingle(); br.ReadSingle(); br.ReadBoolean(); br.ReadInt32(); br.ReadInt32(); br.ReadBoolean(); br.ReadInt32(); br.ReadInt32(); br.ReadBoolean(); br.ReadInt32(); br.ReadString(); br.ReadBoolean(); br.ReadString(); br.ReadString(); br.ReadString(); br.ReadBytes(16); ExtendedSave.internalSceneDictionary.Clear(); try { string marker = br.ReadString(); int ver = br.ReadInt32(); int length = br.ReadInt32(); if (marker.Equals(Marker) && length > 0) { byte[] bytes = br.ReadBytes(length); ExtendedSave.internalSceneDictionary = MessagePackSerializer.Deserialize <Dictionary <string, PluginData> >(bytes); } } catch (EndOfStreamException) { /* Incomplete/non-existant data */ } catch (InvalidOperationException) { /* Invalid/unexpected deserialized data */ } ExtendedSave.SceneImportEvent(path); }
public T Deserialize <T>(byte[] content) { Ensure.Argument.NotNull(content, nameof(content)); return(MessagePackSerializer.Deserialize <T>(content)); }
/// <summary> /// Reads an <see cref="Invocation"/> from a byte array. /// </summary> /// <param name="message"></param> /// <returns></returns> public static Invocation Read(byte[] message) { return(MessagePackSerializer.Deserialize <Invocation>(message)); }
private static void Benchmark <T>(T target) { const int Iteration = 10000; Console.WriteLine("Running {0} iterations...", Iteration); var jsonSerializer = new JsonSerializer(); MsgPack.Serialization.SerializationContext msgpack = MsgPack.Serialization.SerializationContext.Default; msgpack.GetSerializer <T>().PackSingleObject(target); MessagePackSerializer.Serialize(target); MessagePackSerializer.Serialize(target, MessagePackSerializerOptions.LZ4Standard); ZeroFormatter.ZeroFormatterSerializer.Serialize(target); ProtoBuf.Serializer.Serialize(new MemoryStream(), target); jsonSerializer.Serialize(new JsonTextWriter(new StringWriter()), target); Console.WriteLine(typeof(T).Name + " serialization test"); Console.WriteLine(); Console.WriteLine("Serialize::"); Deserializing = false; byte[] data = null; var data0 = new Nerdbank.Streams.Sequence <byte>(); byte[] data1 = null; byte[] data2 = null; byte[] data3 = null; byte[] dataJson = null; byte[] dataGzipJson = null; using (new Measure("MessagePack for C#")) { for (int i = 0; i < Iteration; i++) { data0.Reset(); MessagePackSerializer.Serialize(data0, target); } } using (new Measure("MessagePack for C# (LZ4)")) { for (int i = 0; i < Iteration; i++) { data3 = MessagePackSerializer.Serialize(target, MessagePackSerializerOptions.LZ4Standard); } } using (new Measure("MsgPack-Cli")) { for (int i = 0; i < Iteration; i++) { data = msgpack.GetSerializer <T>().PackSingleObject(target); } } using (new Measure("protobuf-net")) { for (int i = 0; i < Iteration; i++) { using (var ms = new MemoryStream()) { ProtoBuf.Serializer.Serialize(ms, target); } } } using (new Measure("ZeroFormatter")) { for (int i = 0; i < Iteration; i++) { data1 = ZeroFormatter.ZeroFormatterSerializer.Serialize(target); } } using (new Measure("Json.NET")) { for (int i = 0; i < Iteration; i++) { using (var ms = new MemoryStream()) using (var sw = new StreamWriter(ms, Encoding.UTF8, 1024, true)) using (var jw = new JsonTextWriter(sw)) { jsonSerializer.Serialize(jw, target); } } } using (new Measure("Json.NET(+GZip)")) { for (int i = 0; i < Iteration; i++) { using (var ms = new MemoryStream()) using (var gzip = new GZipStream(ms, CompressionLevel.Fastest)) using (var sw = new StreamWriter(gzip, Encoding.UTF8, 1024, true)) using (var jw = new JsonTextWriter(sw)) { jsonSerializer.Serialize(jw, target); } } } using (var ms = new MemoryStream()) { ProtoBuf.Serializer.Serialize(ms, target); data2 = ms.ToArray(); } using (var ms = new MemoryStream()) { using (var sw = new StreamWriter(ms, Encoding.UTF8, 1024, true)) using (var jw = new JsonTextWriter(sw)) { jsonSerializer.Serialize(jw, target); } dataJson = ms.ToArray(); } using (var ms = new MemoryStream()) { using (var gzip = new GZipStream(ms, CompressionLevel.Fastest)) using (var sw = new StreamWriter(gzip, Encoding.UTF8, 1024, true)) using (var jw = new JsonTextWriter(sw)) { jsonSerializer.Serialize(jw, target); } dataGzipJson = ms.ToArray(); } msgpack.GetSerializer <T>().UnpackSingleObject(data); MessagePackSerializer.Deserialize <T>(data0); ////ZeroFormatterSerializer.Deserialize<T>(data1); ProtoBuf.Serializer.Deserialize <T>(new MemoryStream(data2)); MessagePackSerializer.Deserialize <T>(data3, MessagePackSerializerOptions.LZ4Standard); jsonSerializer.Deserialize <T>(new JsonTextReader(new StreamReader(new MemoryStream(dataJson)))); Console.WriteLine(); Console.WriteLine("Deserialize::"); Deserializing = true; using (new Measure("MessagePack for C#")) { for (int i = 0; i < Iteration; i++) { MessagePackSerializer.Deserialize <T>(data0); } } using (new Measure("MessagePack for C# (LZ4)")) { for (int i = 0; i < Iteration; i++) { MessagePackSerializer.Deserialize <T>(data3, MessagePackSerializerOptions.LZ4Standard); } } using (new Measure("MsgPack-Cli")) { for (int i = 0; i < Iteration; i++) { msgpack.GetSerializer <T>().UnpackSingleObject(data); } } using (new Measure("protobuf-net")) { for (int i = 0; i < Iteration; i++) { using (var ms = new MemoryStream(data2)) { ProtoBuf.Serializer.Deserialize <T>(ms); } } } using (new Measure("ZeroFormatter")) { for (int i = 0; i < Iteration; i++) { ZeroFormatterSerializer.Deserialize <T>(data1); } } using (new Measure("Json.NET")) { for (int i = 0; i < Iteration; i++) { using (var ms = new MemoryStream(dataJson)) using (var sr = new StreamReader(ms, Encoding.UTF8)) using (var jr = new JsonTextReader(sr)) { jsonSerializer.Deserialize <T>(jr); } } } using (new Measure("Json.NET(+GZip)")) { for (int i = 0; i < Iteration; i++) { using (var ms = new MemoryStream(dataGzipJson)) using (var gzip = new GZipStream(ms, CompressionMode.Decompress)) using (var sr = new StreamReader(gzip, Encoding.UTF8)) using (var jr = new JsonTextReader(sr)) { jsonSerializer.Deserialize <T>(jr); } } } Console.WriteLine(); Console.WriteLine("FileSize::"); var label = string.Empty; label = "MessagePack for C#"; Console.WriteLine($"{label,-25} {data0.Length,14} byte"); label = "MessagePack for C# (LZ4)"; Console.WriteLine($"{label,-25} {data3.Length,14} byte"); label = "MsgPack-Cli"; Console.WriteLine($"{label,-25} {data.Length,14} byte"); label = "protobuf-net"; Console.WriteLine($"{label,-25} {data2.Length,14} byte"); label = "ZeroFormatter"; Console.WriteLine($"{label,-25} {data1.Length,14} byte"); label = "Json.NET"; Console.WriteLine($"{label,-25} {dataJson.Length,14} byte"); label = "Json.NET(+GZip)"; Console.WriteLine($"{label,-25} {dataGzipJson.Length,14} byte"); Console.WriteLine(); Console.WriteLine(); }
#pragma warning restore DF0000 // Marks undisposed anonymous objects from object creations. #pragma warning restore DF0001 // Marks undisposed anonymous objects from method invocations. // ReSharper restore ExplicitCallerInfoArgument /// <summary> /// Records/playbacks the <see cref="HttpResponseMessage" /> to specified <see cref="HttpRequestMessage" />. /// </summary> /// <param name="request">The request.</param> /// <param name="getResponseAsync">The function to call if a recording is needed.</param> /// <param name="options">The options.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="callerFilePath">The caller file path; set automatically.</param> /// <param name="callerMemberName">Name of the caller member; set automatically.</param> /// <param name="callerLineNumber">The caller line number; set automatically.</param> /// <returns> /// The <see cref="HttpResponseMessage" />. /// </returns> /// <exception cref="ArgumentNullException">request /// or /// request</exception> /// <exception cref="ArgumentOutOfRangeException">mode - null</exception> public async Task <HttpResponseMessage> RecordAsync( HttpRequestMessage request, GetResponseAsync getResponseAsync, CassetteOptions options = null, CancellationToken cancellationToken = default(CancellationToken), [CallerFilePath] string callerFilePath = "", [CallerMemberName] string callerMemberName = "", [CallerLineNumber] int callerLineNumber = 0) { if (request is null) { throw new ArgumentNullException(nameof(request)); } if (getResponseAsync is null) { throw new ArgumentNullException(nameof(request)); } // Overwrite defaults with options options = DefaultOptions & options; // ReSharper disable once PossibleInvalidOperationException RecordMode mode = options.Mode.Value; // If we're in 'none' mode skip recording. if (mode == RecordMode.None) { return(await getResponseAsync(request, cancellationToken).ConfigureAwait(false)); } // Ensure request has been completed before serialization attempts if (!(request.Content is null)) { await request.Content.LoadIntoBufferAsync().ConfigureAwait(false); } // Get key data. byte[] key = await KeyGenerator.Generate(request, cancellationToken); // Get key data hash. string hash = key.GetKeyHash(); /* * Lock based on hash - so only one operation is allowed for the same hash at the same time. */ IDisposable @lock = await _keyedSemaphoreSlim.WaitAsync(hash, cancellationToken); try { // Try to get recording from the store. Recording recording; bool found = false; HttpResponseMessage response = null; byte[] recordingData = null; /* * Unless we're in overwrite mode, try to get a response from the store. */ if (mode != RecordMode.Overwrite) { // Logs an error // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local void Error(string message, Exception exception = null, bool @throw = false) { CassetteException cassetteException = new CassetteException( message, Store.Name, callerFilePath, callerMemberName, callerLineNumber, exception); if (@throw) { Logger.LogCritical(cassetteException); throw cassetteException; } Logger.LogError(cassetteException); recording = null; found = false; } try { recordingData = await Store.GetAsync(hash, cancellationToken); } catch (Exception e) { Error("The underlying store threw an exception when attempting to retrieve a recording.", e); } // If we got a response and it has more than 0 bytes consider it fond! if (!(recordingData is null) && recordingData.Length > 0) { found = true; // If we're in recording mode don't bother to deserialize it as we're not going to use it if (mode != RecordMode.Record) { // Deserialize recording try { recording = MessagePackSerializer.Deserialize <Recording>(recordingData, RecorderResolver.Instance); } catch (Exception e) { Error("The recording could not be deserialized.", e); } // Validate key if (found && !string.Equals(hash, recording.Hash)) { Error("The recording's hash did not match, ignoring."); } if (found && !string.Equals(KeyGenerator.Name, recording.KeyGeneratorName)) { Error("The recording's key generator name did not match, ignoring."); } /* * If we're in playback or auto mode we need to replay response */ if (found && (mode == RecordMode.Playback || mode == RecordMode.Auto)) { if (recording.ResponseData is null) { Error("No response data found in recording, ignoring."); } // Deserialize response if (found) { try { response = MessagePackSerializer.Deserialize <HttpResponseMessage>( recording.ResponseData, RecorderResolver.Instance); } catch (Exception e) { Error("Failed to deserialize the response from the store, ignoring.", e); } } // ReSharper disable once PossibleInvalidOperationException RequestPlaybackMode requestPlaybackMode = options.RequestPlaybackMode.Value; if (found) { if (recording.RequestData is null || requestPlaybackMode == RequestPlaybackMode.IgnoreRecorded) { if (requestPlaybackMode == RequestPlaybackMode.UseRecorded) { Error( "No request found in the recording, and in RequestPlaybackMode UseRecorded.", null, true); } // ReSharper disable once PossibleNullReferenceException response.RequestMessage = request; } else { // Deserialize request try { #pragma warning disable DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation. // ReSharper disable once PossibleNullReferenceException response.RequestMessage = MessagePackSerializer.Deserialize <HttpRequestMessage>( recording.RequestData, RecorderResolver.Instance); #pragma warning restore DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation. } catch (Exception e) { if (requestPlaybackMode == RequestPlaybackMode.UseRecorded) { Error( "Failed to deserialize the request from the store, and in RequestPlaybackMode UseRecorded.", e, true); } else { Error("Failed to deserialize the request from the store, ignoring.", e); } } } } // ReSharper disable once PossibleInvalidOperationException if (found) { TimeSpan simulateDelay = options.SimulateDelay.Value; if (simulateDelay != default(TimeSpan)) { int delay = simulateDelay < TimeSpan.Zero ? recording.DurationMs : (int)simulateDelay.TotalMilliseconds; Logger.LogInformation( $"Responding with matching recording from '{recording.RecordedUtc.ToLocalTime()}' after {delay}ms simulated delay.", Store.Name, callerFilePath, callerMemberName, callerLineNumber); await Task.Delay(delay, cancellationToken); } else { Logger.LogInformation( $"Responding with matching recording from '{recording.RecordedUtc.ToLocalTime()}'.", Store.Name, callerFilePath, callerMemberName, callerLineNumber); } return(response); } } } } } // If we're in playback mode we've failed to get a recording so error if (mode == RecordMode.Playback) { // Recording not found so error in playback mode. CassetteNotFoundException exception = new CassetteNotFoundException( Store.Name, callerFilePath, callerMemberName, callerLineNumber); Logger.LogError(exception); throw exception; } /* * Record original request to detect changes if options set to RequestRecordMode.RecordIfChanged */ byte[] requestData; // ReSharper disable once PossibleInvalidOperationException RequestRecordMode requestRecordMode = options.RequestRecordMode.Value; if (!found && requestRecordMode == RequestRecordMode.RecordIfChanged) { // If the key was generated with the FullRequestKeyGenerator.Instance then the request is already serialized. if (ReferenceEquals(KeyGenerator, FullRequestKeyGenerator.Instance)) { requestData = key; } else { try { requestData = MessagePackSerializer.Serialize(request, RecorderResolver.Instance); } catch (Exception e) { CassetteException ce = new CassetteException( "Failed to serialize the request.", Store.Name, callerFilePath, callerMemberName, callerLineNumber, e); Logger.LogCritical(ce); throw ce; } } } else { requestData = null; } /* * Retrieve response from endpoint. */ int durationMs; DateTime recordedUtc; try { // Use stopwatch to record how long it takes to get a response. Stopwatch stopwatch = Stopwatch.StartNew(); #pragma warning disable DF0010 // Marks undisposed local variables. response = await getResponseAsync(request, cancellationToken).ConfigureAwait(false); #pragma warning restore DF0010 // Marks undisposed local variables. durationMs = (int)stopwatch.ElapsedMilliseconds; recordedUtc = DateTime.UtcNow; } catch (Exception e) { // TODO We could save the exception an repeat on playback, useful for testing handlers // Unfortunately MessagePack-CSharp doesn't support exception serialization normally so would need to be // handled in a custom way. CassetteException re = new CassetteException("Fatal error occured retrieving the response.", Store.Name, callerFilePath, callerMemberName, callerLineNumber, e); Logger.LogError(re); throw re; } // If we have a recording, don't overwrite just return the new response here. if (found) { Logger.LogInformation( "Existing recording found so not overwriting it.", Store.Name, callerFilePath, callerMemberName, callerLineNumber); return(response); } // Serialize response byte[] responseData; try { responseData = MessagePackSerializer.Serialize(response, RecorderResolver.Instance); } catch (Exception e) { CassetteException re = new CassetteException( "Failed to serialize response, not storing.", Store.Name, callerFilePath, callerMemberName, callerLineNumber, e); Logger.LogError(re); return(response); } if (requestRecordMode != RequestRecordMode.Ignore) { byte[] oldRequestData = requestData; // Serialize the request try { requestData = MessagePackSerializer.Serialize(response.RequestMessage, RecorderResolver.Instance); // If we're only recording requests on change, check for changes if (requestRecordMode == RequestRecordMode.RecordIfChanged && // ReSharper disable once AssignNullToNotNullAttribute requestData.SequenceEqual(oldRequestData)) { requestData = null; } } catch (Exception e) { CassetteException re = new CassetteException( "Failed to serialize response's request message, so ignoring check.", Store.Name, callerFilePath, callerMemberName, callerLineNumber, e); Logger.LogError(re); requestData = null; } } // Create new recording recording = new Recording( hash, KeyGenerator.Name, recordedUtc, durationMs, responseData, requestData); // Finally serialize the recording try { recordingData = MessagePackSerializer.Serialize(recording, RecorderResolver.Instance); } catch (Exception e) { CassetteException re = new CassetteException( "Failed to serialize recording, not storing.", Store.Name, callerFilePath, callerMemberName, callerLineNumber, e); Logger.LogError(re); return(response); } // Set the response Logger.LogInformation( $"Recording response at '{recordedUtc.ToLocalTime()}' (took {durationMs} ms).", Store.Name, callerFilePath, callerMemberName, callerLineNumber); if (options.WaitForSave == true) { try { await Store.StoreAsync(hash, recordingData); } catch (Exception e) { // Just log the error. CassetteException re = new CassetteException( "Failed to store recording.", Store.Name, callerFilePath, callerMemberName, callerLineNumber, e); Logger.LogError(re); } // We can now dispose the lock safely. @lock.Dispose(); } else { // Store the recording asynchronously, and don't wait the result (errors will be logged and suppressed). StoreAsync(hash, recordingData, @lock, callerFilePath, callerMemberName, callerLineNumber); } // Return the response. return(response); }
public TOut Deserialize <TOut>(string input) { return(MessagePackSerializer.Deserialize <TOut>(Encoding.UTF8.GetBytes(input), _options)); }
private static T Deserialize <T>(byte[] buf) { return(MessagePackSerializer.Deserialize <T>(buf)); }
/// <inheritdoc/> public JsonRpcMessage Deserialize(ReadOnlySequence <byte> contentBuffer) => (JsonRpcMessage)MessagePackSerializer.Deserialize <object>(contentBuffer.AsStream(), this.options);
private List <T> ReadBytes(byte[] bytes) => MessagePackSerializer.Deserialize <List <T> >(bytes);
public static async Task ReqRepTest(int LoopNum) { string requestTopic = "mytopic/A/request"; var sw = new System.Diagnostics.Stopwatch(); sw.Start(); using (var cts = new CancellationTokenSource()) using (var startedev = new ManualResetEventSlim()) using (var connectedev = new ManualResetEventSlim()) using (var recvev = new ManualResetEventSlim()) { var fac = new MqttFactory(); await Task.WhenAll( Task.Run(async() => { var svr = fac.CreateMqttServer(); var msgbuilder = new MqttApplicationMessageBuilder().WithPayload("req"); svr.ApplicationMessageReceived += async(sender, ev) => { if (ev.ApplicationMessage.Topic.Equals(requestTopic, StringComparison.Ordinal)) { var reqmsg = MessagePackSerializer.Deserialize <ReqMsg>(ev.ApplicationMessage.Payload); var msg = msgbuilder.WithTopic(reqmsg.ReplyTopic).Build(); await svr.PublishAsync(msg); } }; svr.Started += (sender, ev) => { startedev.Set(); }; var opt = new MqttServerOptionsBuilder() .WithDefaultEndpoint() .WithDefaultEndpointBoundIPAddress(IPAddress.Loopback) .WithDefaultEndpointPort(10012) .Build(); await svr.StartAsync(opt).ConfigureAwait(false); cts.Token.WaitHandle.WaitOne(); await svr.StopAsync().ConfigureAwait(false); }) , Task.Run(async() => { var client = fac.CreateMqttClient(); string replyTopic = "mytopic/A/reply"; var queue = new ConcurrentQueue <TaskCompletionSource <byte[]> >(); client.ApplicationMessageReceived += (sender, ev) => { if (queue.TryDequeue(out var tcs)) { tcs.TrySetResult(ev.ApplicationMessage.Payload); } }; client.Connected += (sender, ev) => { connectedev.Set(); }; var clientopt = new MqttClientOptionsBuilder() .WithClientId("clid") .WithTcpServer("localhost", 10012) .Build() ; await client.ConnectAsync(clientopt).ConfigureAwait(false); connectedev.Wait(); var topicFilter = new TopicFilterBuilder() .WithTopic(replyTopic) .WithAtLeastOnceQoS() .Build() ; await client.SubscribeAsync(topicFilter).ConfigureAwait(false); Console.WriteLine($"client task loop started:{sw.Elapsed}"); var beginTime = sw.Elapsed; var msgbuilder = new MqttApplicationMessageBuilder().WithTopic(requestTopic); for (int i = 0; i < LoopNum; i++) { var reqpayload = MessagePackSerializer.Serialize(new ReqMsg(replyTopic, "hoge")); var msg = msgbuilder .WithPayload(reqpayload) .Build(); ; var reqtcs = new TaskCompletionSource <byte[]>(); queue.Enqueue(reqtcs); await client.PublishAsync(msg).ConfigureAwait(false); await reqtcs.Task; } var endTime = sw.Elapsed; Console.WriteLine($"elapsed(mqtt):{sw.Elapsed},rps={LoopNum/(endTime.Subtract(beginTime).TotalSeconds)}"); }).ContinueWith(t => { Console.WriteLine($"all client task done:{sw.Elapsed}"); cts.Cancel(); if (t.IsCanceled) { throw new TaskCanceledException("server task cancelled", t.Exception); } else if (t.IsFaulted) { throw new AggregateException(t.Exception); } }) ).ConfigureAwait(false); } }
private static void Main() { var builder = new ConnectionListenerBuilder() .ListenOn(new UdpEndPoint("127.0.0.1", 45685)) .ConfigureChannels(builder => builder.AddChannel <ReliableOrderedChannel>(0)) .UseLogger(PegiLogging.Configure("Server")) ; using (var listener = builder.Build()) using (var resetEvent = new ManualResetEventSlim(false)) { Console.CancelKeyPress += (_, e) => { e.Cancel = true; Log.Information("Ctrl+C"); resetEvent.Set(); }; var connections = new ConcurrentDictionary <UdpEndPoint, Connection>(); listener.NewConnection += (_, connection) => { Log.Information("[{ConnectionEndPoint}] New connection", connection.RemoteEndPoint); connection.Disconnected += (_) => { Log.Information("[{ConnectionEndPoint}] Disconnected", connection.RemoteEndPoint); connections.TryRemove(connection.RemoteEndPoint, out _); }; connection.MessageReceived += (_, data) => { var message = MessagePackSerializer.Deserialize <DebugMessage>(data); Log.Information("[{ConnectionEndPoint}] Message: {Message}", connection.RemoteEndPoint, message); connection.SendMessage(data); }; connections.TryAdd(connection.RemoteEndPoint, connection); }; listener.Run(); var updateTime = 60; while (!resetEvent.IsSet) { foreach (var connection in connections.Values) { try { connection.Update(); } catch (Exception e) { Log.Error(e, "Update error"); connection.Dispose(); } } Thread.Sleep(1000 / updateTime); } Log.Information("Disconnecting..."); } Log.Information("Disconnected"); Thread.Sleep(1000); }
public static ResolveInfo Deserialize(byte[] data) => MessagePackSerializer.Deserialize <ResolveInfo>(data);
/// <summary> /// Read a packet after the type has been resolved /// </summary> /// <typeparam name="T">Type of packet</typeparam> /// <param name="reader">NetDataReader to read from</param> /// <returns>Packet Object</returns> public T read_packet <T>(NetDataReader reader) { var data = reader.GetBytesWithLength(); return(MessagePackSerializer.Deserialize <T>(data)); }
public static AnimationControllerInfo Unserialize(byte[] data) { return(MessagePackSerializer.Deserialize <AnimationControllerInfo>(data)); }
public IMessage Read(ArraySegment <byte> data) => MessagePackSerializer.Deserialize <T>(data);