public byte[] MakePacket(string label, DateTime timestamp, params object[] records) { string tag; if (!string.IsNullOrEmpty(label)) { tag = _tag + "." + label; } else { tag = _tag; } var xs = new List<MessagePackObject>(); xs.Add(tag); var children = new List<MessagePackObject>(); foreach (var record in records) { var child = new List<MessagePackObject>(); child.Add(timestamp.ToUniversalTime().Subtract(_epoc).TotalSeconds); child.Add(CreateTypedMessagePackObject(record.GetType(), record, first:true)); children.Add(new MessagePackObject(child)); } xs.Add(new MessagePackObject(children)); var x = new MessagePackObject(xs); var ms = new MemoryStream(); var packer = Packer.Create(ms); packer.Pack(x); return ms.ToArray(); }
/// <summary> /// Initialize new instance with unpacked data. /// </summary> /// <param name="rpcError"> /// Metadata of error. If you specify null, <see cref="MsgPack.Rpc.RpcError.RemoteRuntimeError"/> is used. /// </param> /// <param name="unpackedException"> /// Exception data from remote MessagePack-RPC server. /// </param> /// <exception cref="SerializationException"> /// Cannot deserialize instance from <paramref name="unpackedException"/>. /// </exception> protected internal RpcException( RpcError rpcError, MessagePackObject unpackedException ) : this( rpcError, unpackedException.GetString( MessageKeyUtf8 ), unpackedException.GetString( DebugInformationKeyUtf8 ) ) { if ( unpackedException.IsDictionary ) { MessagePackObject mayBeArray; if ( unpackedException.AsDictionary().TryGetValue( _remoteExceptionsUtf8, out mayBeArray ) && mayBeArray.IsArray ) { var array = mayBeArray.AsList(); this._remoteExceptions = new RemoteExceptionInformation[ array.Count ]; for ( int i = 0; i < this._remoteExceptions.Length; i++ ) { if ( array[ i ].IsList ) { this._remoteExceptions[ i ] = new RemoteExceptionInformation( array[ i ].AsList() ); } else { // Unexpected type. Debug.WriteLine( "Unexepcted ExceptionInformation at {0}, type: {1}, value: \"{2}\".", i, array[ i ].UnderlyingType, array[ i ] ); this._remoteExceptions[ i ] = new RemoteExceptionInformation( new MessagePackObject[] { array[ i ] } ); } } } } #if !SILVERLIGHT && !MONO this.RegisterSerializeObjectStateEventHandler(); #endif }
public static bool MsgUnPackTable(out LuaTable luatable, ref MessagePackObject pObj) { LuaTable result = new LuaTable(); luatable = result; var mPk = pObj.AsDictionary(); bool isString = false; string key; object value; foreach (var item in mPk) { //parse for key MessagePackObject mKey = item.Key; if (mKey.IsRaw) { key = mKey.AsString(); isString = true; } else if (true == mKey.IsTypeOf<double>()) { key = mKey.AsDouble().ToString(); } else { LoggerHelper.Error("key type error"); return false; } //parse for value MessagePackObject mValue = item.Value; if (mValue.IsRaw) { value = mValue.AsString(); } else if (mValue.IsDictionary) { LuaTable luatbl; MsgUnPackTable(out luatbl, ref mValue); value = luatbl; } else if (true == mValue.IsTypeOf<bool>()) { value = mValue.AsBoolean(); } else if (true == mValue.IsTypeOf<double>()) { value = mValue.AsDouble(); } else { LoggerHelper.Error("value type error"); return false; } result.Add(key, isString, value); isString = false; } return true; }
public void TestAsByteOverflow() { var target = new MessagePackObject( Byte.MaxValue + 1 ); Assert.Throws<InvalidOperationException>( () => { var result = ( Byte )target; Console.WriteLine( "TestAsByteOverflow:0x{0:x}({0:#,0})[{1}]", result, result.GetType() ); } ); }
public void TestAsInt16Underflow() { var target = new MessagePackObject(Int16.MinValue - 1); Assert.Throws <InvalidOperationException>( () => { var result = ( Int16 )target; Console.WriteLine("TestAsInt16Overflow:0x{0:x}({0:#,0})[{1}]", result, result.GetType()); } ); }
public static TimeSpan?GetTimeSpan(this MessagePackObject source, MessagePackObject key) { if (source.IsDictionary) { if (source.AsDictionary().TryGetValue(key, out var value) && value.IsTypeOf <long>().GetValueOrDefault()) { return(new TimeSpan(value.AsInt64())); } } return(null); }
public void SetPlayerData(string id, MessagePackObject data) { _playerData[id] = data; _scene.Broadcast(PLAYERDATA_UPDATED_ROUTE, new PlayerDataUpdate { PlayerId = id, Data = data }, PacketPriority.LOW_PRIORITY, PacketReliability.RELIABLE_ORDERED ); }
/// <summary> /// Initialize new instance. /// </summary> /// <param name="error">Error information of the error.</param> /// <param name="detail">Unpacked detailed information of the error which was occurred in remote endpoint.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="error"/> is null. /// </exception> public RpcErrorMessage( RpcError error, MessagePackObject detail ) { if ( error == null ) { throw new ArgumentNullException( "error" ); } Contract.EndContractBlock(); this._error = error; this._detail = detail; }
/// <summary> /// </summary> /// <param name="objects"> /// </param> /// <returns> /// </returns> public static string List(MessagePackObject[] objects) { string output = string.Empty; foreach (MessagePackObject mpo in objects) { // Using \r\n here with purpose, dont change to Environment.NewLine output += mpo.UnderlyingType.ToString() + ": " + mpo.ToString() + "\r\n"; } return output; }
public static string GetString(this MessagePackObject source, MessagePackObject key) { if (source.IsDictionary) { if (source.AsDictionary().TryGetValue(key, out var value) && value.IsTypeOf <string>().GetValueOrDefault()) { return(value.AsString()); } } return(null); }
public void TestAsSByteOverflow() { var target = new MessagePackObject(SByte.MaxValue + 1); Assert.Throws <InvalidOperationException>( () => { var result = ( SByte )target; Console.WriteLine("TestAsSByteOverflow:0x{0:x}({0:#,0})[{1}]", result, result.GetType()); } ); }
public void TestDynamicInvocation_Success() { string arg = Guid.NewGuid().ToString(); int messageId = Environment.TickCount % 1000; string methodName = "SomeMethod"; using (var environment = new InProcTestEnvironment((method, id, args) => method == methodName && args[0].AsString() == arg)) using (dynamic target = new DynamicRpcProxy(environment.EndPoint, environment.Configuration)) { MessagePackObject result = target.SomeMethod(arg); Assert.That(result == true); } }
private Color ReadColor(MessagePackObject o) { var l = o.AsList(); if (l.Count == 4) { return(new Color(l[0].AsSingle(), l[1].AsSingle(), l[2].AsSingle(), l[3].AsSingle())); } else { return(new Color(l[0].AsSingle(), l[1].AsSingle(), l[2].AsSingle())); } }
public void SetState(MessagePackObject state, int remoteCurrentTime, int remoteElapsedTime) { this.state.Set(state); // TODO: // Create a "clock" for remoteCurrentTime / remoteElapsedTime to match the JavaScript API. // Creates serializer. var serializer = MessagePackSerializer.Get <MessagePackObject>(); this.OnUpdate.Invoke(this, new RoomUpdateEventArgs(this, state, null)); this._previousState = serializer.PackSingleObject(state); }
public static string GetString( this MessagePackObject source, MessagePackObject key ) { if ( source.IsDictionary ) { MessagePackObject value; if ( source.AsDictionary().TryGetValue( key, out value ) && value.IsTypeOf<string>().GetValueOrDefault() ) { return value.AsString(); } } return null; }
private static void TestRuntimeSerializationCore(MessagePackObject target) { var formatter = new BinaryFormatter(); using (var stream = new MemoryStream()) { formatter.Serialize(stream, target); stream.Position = 0; var actual = ( MessagePackObject )formatter.Deserialize(stream); Assert.AreEqual(target, actual); } }
public static TimeSpan? GetTimeSpan( this MessagePackObject source, MessagePackObject key ) { if ( source.IsDictionary ) { MessagePackObject value; if ( source.AsDictionary().TryGetValue( key, out value ) && value.IsTypeOf<Int64>().GetValueOrDefault() ) { return new TimeSpan( value.AsInt64() ); } } return null; }
public void TestEquals_Map_SubMap_False() { var target = new MessagePackObject(new MessagePackObjectDictionary() { { "A", 1 }, { "B", 2 }, { "C", 3 } }); var other = new MessagePackObject(new MessagePackObjectDictionary() { { "A", 1 }, { "B", 2 } }); Assert.IsFalse(target.Equals(other)); }
private static object MapDateTime(PropertyInfo property, MessagePackObject source) { var conversionMethod = property?.GetCustomAttribute <MessagePackDateTimeMemberAttribute>() ?.DateTimeConversionMethod; switch (conversionMethod) { case DateTimeMemberConversionMethod.UnixEpoc: var epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc); return(epoch.AddMilliseconds(source.AsInt64())); default: return(DateTime.FromBinary(source.AsInt64())); } }
private static object MapEnum(Type targetType, MessagePackObject source) { if (source.IsTypeOf <int>() ?? false) { return(source.AsInt32()); } if (source.IsTypeOf <string>() ?? false) { var strVal = source.AsString(); return(Enum.Parse(targetType, strVal, true)); } throw new MessagePackMapperException($"Cannot map value to enum {targetType.FullName}."); }
protected internal override async Task <object> UnpackFromAsyncCore(Unpacker unpacker, CancellationToken cancellationToken) { if (unpacker.IsArrayHeader) { var result = new MessagePackObject[UnpackHelpers.GetItemsCount(unpacker)]; for (int i = 0; i < result.Length; i++) { var item = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false); if (!item.Success) { SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker); } result[i] = item.Value; } return(new MessagePackObject(result)); } else if (unpacker.IsMapHeader) { var itemsCount = UnpackHelpers.GetItemsCount(unpacker); var result = new MessagePackObjectDictionary(itemsCount); for (int i = 0; i < itemsCount; i++) { var key = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false); if (!key.Success) { SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker); } var value = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false); if (!value.Success) { SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker); } result.Add(key.Value, value.Value); } return(new MessagePackObject(result)); } else { var result = unpacker.LastReadData; return(result.IsNil ? MessagePackObject.Nil : result); } }
private static void TestInt(int val) { MessagePackObject objInt = val; MessagePackObject objLong = ( long )val; #pragma warning disable 1718 Assert.IsTrue(objInt == objInt); #pragma warning restore 1718 Assert.IsTrue(objInt == objLong); Assert.IsTrue(objLong == objInt); #pragma warning disable 1718 Assert.IsTrue(objLong == objLong); #pragma warning restore 1718 }
public static string DeserializeAsString(this MessagePackObject source) { string str; try { str = source.AsString(); } catch (InvalidOperationException exception) { throw new SerializationException(string.Format(CultureInfo.CurrentCulture, "The unpacked value is not expected type. {0}", new object[] { exception.Message }), exception); } return(str); }
protected override async Task <bool> ReadAsyncCore(CancellationToken cancellationToken) { var result = await this.ReadSubtreeObjectAsync(/* isDeep */ false, cancellationToken).ConfigureAwait(false); if (result.Success) { this.InternalData = result.Value; return(true); } else { return(false); } }
protected void ReadPrimitive() { MessagePackObject lastReadData = mUnpacker.LastReadData; if (lastReadData.IsNil) { mReader.SetToken(JsonToken.Null, null); } else if (lastReadData.UnderlyingType == typeof(byte[])) { mReader.SetToken(JsonToken.Bytes, lastReadData.AsBinary()); } else if (lastReadData.UnderlyingType == typeof(bool)) { mReader.SetToken(JsonToken.Boolean, lastReadData.AsBoolean()); } else if (lastReadData.UnderlyingType == typeof(string)) { mReader.SetToken(JsonToken.String, lastReadData.AsString()); } else if (lastReadData.UnderlyingType == typeof(double) || lastReadData.UnderlyingType == typeof(float)) { mReader.SetToken(JsonToken.Float, lastReadData.ToObject()); } else if (lastReadData.IsTypeOf <sbyte>() == true || lastReadData.IsTypeOf <short>() == true || lastReadData.IsTypeOf <ushort>() == true || lastReadData.IsTypeOf <int>() == true || lastReadData.IsTypeOf <uint>() == true || lastReadData.IsTypeOf <long>() == true || lastReadData.IsTypeOf <ulong>() == true) { mReader.SetToken(JsonToken.Integer, lastReadData.ToObject()); } }
protected override bool ReadCore() { MessagePackObject value; var success = this.ReadSubtreeObject(out value); if (success) { this.InternalData = value; return(true); } else { return(false); } }
private void ReadEdge(MessagePackObject edgeObj, Voxel voxel) { var edgeList = edgeObj.AsList(); if (edgeList.Count == 0) { return; } int edgeI = edgeList[0].AsInt32(); if (edgeList.Count >= 2) { voxel.edges[edgeI].bevel = edgeList[1].AsByte(); } }
/// <inheritdoc /> public object Unpack(MessagePackObject obj) { if (obj.IsList) { IList <MessagePackObject> list = obj.AsList(); return(this.Unpack(list)); } if (obj.IsMap) { MessagePackObjectDictionary map = obj.AsDictionary(); return(map.ToDictionary(k => k.Key.ToString(), k => Unpack(k.Value))); } return(obj.ToObject()); }
public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { ICharacter character = (ICharacter)self; int statelId = (int)((uint)0xC0000000 | arguments[1].AsInt32() | (arguments[2].AsInt32() << 16)); character.Stats[StatIds.externaldoorinstance].BaseValue = 0; character.Stats[StatIds.externalplayfieldinstance].BaseValue = 0; if (arguments[1].AsInt32() > 0) { StatelData sd = PlayfieldLoader.PFData[arguments[1].AsInt32()].GetDoor(statelId); if (sd == null) { throw new Exception( "Statel " + arguments[3].AsInt32().ToString("X") + " not found? Check the rdb dammit"); } Vector3 v = new Vector3(sd.X, sd.Y, sd.Z); Quaternion q = new Quaternion(sd.HeadingX, sd.HeadingY, sd.HeadingZ, sd.HeadingW); Quaternion.Normalize(q); Vector3 n = (Vector3)q.RotateVector3(Vector3.AxisZ); v.x += n.x * 2.5; v.z += n.z * 2.5; character.Playfield.Teleport( (Dynel)character, new Coordinate(v), q, new Identity() { Type = (IdentityType)arguments[0].AsInt32(), Instance = arguments[1].AsInt32() }); } return true; self.Stats[StatIds.externalplayfieldinstance].Value = 0; self.Stats[StatIds.externaldoorinstance].Value = 0; self.Playfield.Teleport( (Dynel)self, new Coordinate(100, 10, 100), ((ICharacter)self).Heading, new Identity() { Type = (IdentityType)arguments[0].AsInt32(), Instance = arguments[1].AsInt32() }); return true; }
public void TestNestedArray() { var output = new MemoryStream(); Packer.Create(output).Pack(new[] { new int[0], new[] { 0 }, new[] { 0, 1 } }); MessagePackObject obj = UnpackOne(output); var outer = obj.AsList(); Assert.AreEqual(3, outer.Count); Assert.AreEqual(0, outer[0].AsList().Count); Assert.AreEqual(1, outer[1].AsList().Count); Assert.That(outer[1].AsList()[0].AsInt32(), Is.EqualTo(0).With.TypeOf <int>()); Assert.AreEqual(2, outer[2].AsList().Count); Assert.That(outer[2].AsList()[0].AsInt32(), Is.EqualTo(0).With.TypeOf <int>()); Assert.AreEqual(1, outer[2].AsList()[1].AsInt32()); }
private static void PackValuesAsArray( Packer packer, MessagePackObject memberDefault, MessagePackObject nullButValueType, MessagePackObject nullAndNullableValueType, MessagePackObject nullAndReferenceType, MessagePackObject prohibitReferenceType ) { packer.PackArrayHeader(5); packer.Pack(memberDefault); packer.Pack(nullButValueType); packer.Pack(nullAndNullableValueType); packer.Pack(nullAndReferenceType); packer.Pack(prohibitReferenceType); }
protected override bool ReadCore() { MessagePackObject value; var success = this.ReadSubtreeObject(out value); if (success) { this.InternalData = value; return(true); } // ReSharper disable once RedundantIfElseBlock else { return(false); } }
private static void PackValuesAsArray( Packer packer, MessagePackObject memberDefault, MessagePackObject nullButValueType, MessagePackObject nullAndNullableValueType, MessagePackObject nullAndReferenceType, MessagePackObject prohibitReferenceType ) { packer.PackArrayHeader( 5 ); packer.Pack( memberDefault ); packer.Pack( nullButValueType ); packer.Pack( nullAndNullableValueType ); packer.Pack( nullAndReferenceType ); packer.Pack( prohibitReferenceType ); }
public RPC_Result RPC_SendRawTransaction(IList <MessagePackObject> _params) { var message = _params.First(); var pubkey = this.pubkey; var sign = Helper_NEO.Sign(message.AsBinary(), this.prikey); var signdata = new TransactionSign(); signdata.VScript = pubkey; signdata.IScript = sign; var data = SerializeHelper.SerializeToBinary(signdata); this.Tell_SendRaw(this._System.GetPipeline(this, "this/node"), message.AsBinary(), data); var result = new MessagePackObject(0); return(new RPC_Result(result)); }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { string text = arguments[0].AsString(); var message = new FormatFeedbackMessage() { Identity = self.Identity, FormattedMessage = "~&!!!\":!!!)<s" + (char)(text.Length + 1), Unknown1 = 0, Unknown2 = 0, }; ((ICharacter)self).Send(message); return true; }
// public int GetInstanceID() // { // return this.m_InstanceID; // } // public override bool Equals(object o) // { // return Object.CompareBaseObjects(this, o as Object); // } // private static bool CompareBaseObjects(Object lhs, Object rhs) // { // return lhs == rhs; // if (lhs == null && rhs == null) // return true; // if (lhs != null && rhs != null) // return lhs.m_InstanceID == rhs.m_InstanceID; // // return false; // } // public static T DeepClone<T>(T obj) // { // using (var ms = new MemoryStream()) // { // var formatter = new BinaryFormatter(); // formatter.Serialize(ms, obj); // ms.Position = 0; // // return (T) formatter.Deserialize(ms); // } // } public static Object Instantiate(Object original) { Object.CheckNullArgument((object)original, "The Object you want to instantiate is null."); var gameObject = original as GameObject; if (gameObject != null) { SceneManager.dontAddGameObject = true; } var serializer = UnikonEngine.serializationContext.GetSerializer(original.GetType()); MessagePackObject mpo = serializer.ToMessagePackObject(original); var clone = serializer.FromMessagePackObject(mpo); if (gameObject != null) { #if DEBUG_UNIKON Debug.Log("GameObject Instantiate"); Debug.Log(mpo.ToString()); foreach (var component in (clone as GameObject).components) { Debug.Log(component.GetType().Name); } #endif SceneManager.dontAddGameObject = false; SceneManager.AddGameObject(clone as GameObject); // gameObject.dontAwake = false; // foreach (var component in gameObject.components) // { // var awakeMethod = component.GetType().GetMethod("Awake", // BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); // if (awakeMethod != null) // { // Debug.Log("Invoke Awake " + component.GetType()); // awakeMethod.Invoke(component, BindingFlags.InvokeMethod, null, null, CultureInfo.CurrentCulture); // } // // } } return((Object)clone); }
protected internal override object UnpackFromCore(Unpacker unpacker) { // ReSharper disable RedundantIfElseBlock if (unpacker.IsArrayHeader) { var result = new MessagePackObject[UnpackHelpers.GetItemsCount(unpacker)]; for (int i = 0; i < result.Length; i++) { if (!unpacker.ReadObject(out result[i])) { throw SerializationExceptions.NewUnexpectedEndOfStream(); } } return(new MessagePackObject(result)); } else if (unpacker.IsMapHeader) { var itemsCount = UnpackHelpers.GetItemsCount(unpacker); var result = new MessagePackObjectDictionary(itemsCount); for (int i = 0; i < itemsCount; i++) { MessagePackObject key; if (!unpacker.ReadObject(out key)) { throw SerializationExceptions.NewUnexpectedEndOfStream(); } MessagePackObject value; if (!unpacker.ReadObject(out value)) { throw SerializationExceptions.NewUnexpectedEndOfStream(); } result.Add(key, value); } return(new MessagePackObject(result)); } else { var result = unpacker.LastReadData; return(result.IsNil ? MessagePackObject.Nil : result); } // ReSharper restore RedundantIfElseBlock }
public byte[] ToInitScript() { var dict = new MessagePackObjectDictionary(); dict["magicstr"] = MagicStr; var array = new MessagePackObject[InitOwner.Length]; dict["initowner"] = array; for (var i = 0; i < InitOwner.Length; i++) { array[i] = InitOwner[i]; } var arr = MsgPack_Helper.Pack(new MessagePackObject(dict)); return(arr.ToArray()); }
public void TestIssue269() { var input = new MessagePackObject(Timestamp.UtcNow.Encode()); var target = MessagePackSerializer.UnpackMessagePackObject(MessagePackSerializer.Get <MessagePackObject>().PackSingleObject(input)); Assert.That(target.UnderlyingType, Is.EqualTo(typeof(MessagePackExtendedTypeObject))); Assert.That(target.IsTypeOf <byte[]>(), Is.False); Assert.That(target.IsTypeOf <MessagePackExtendedTypeObject>(), Is.True); var forBinary = Assert.Throws <InvalidOperationException>(() => target.AsBinary()); Assert.That(forBinary.Message, Is.EqualTo("Do not convert MsgPack.MessagePackExtendedTypeObject MessagePackObject to System.Byte[].")); var forString = Assert.Throws <InvalidOperationException>(() => target.AsString()); Assert.That(forString.Message, Is.EqualTo("Do not convert MsgPack.MessagePackExtendedTypeObject MessagePackObject to System.String.")); }
private void ReadVoxel(MessagePackObject voxelObj, VoxelArray voxelArray, List <Material> materials, List <Material> overlays, List <Substance> substances) { var voxelList = voxelObj.AsList(); if (voxelList.Count == 0) { return; } Vector3 position = ReadVector3(voxelList[0]); Voxel voxel = null; if (!editor) { // slightly faster -- doesn't add to octree voxel = voxelArray.InstantiateVoxel(position); } else { voxel = voxelArray.VoxelAt(position, true); } if (voxelList.Count >= 2) { foreach (var faceObj in voxelList[1].AsList()) { ReadFace(faceObj, voxel, materials, overlays); } } if (voxelList.Count >= 3 && voxelList[2].AsInt32() != -1) { voxel.substance = substances[voxelList[2].AsInt32()]; } if (voxelList.Count >= 4) { foreach (var edgeObj in voxelList[3].AsList()) { ReadEdge(edgeObj, voxel); } } voxel.UpdateVoxel(); }
private string ReadReportBuffer(byte[] buffer, string room, UserId userId) { StringBuilder builder = new StringBuilder(); MessagePackObject deserializedReport = MessagePackSerializer.UnpackMessagePackObject(buffer); builder.AppendLine(); builder.AppendLine("PlayReport log:"); if (!userId.IsNull) { builder.AppendLine($" UserId: {userId.ToString()}"); } builder.AppendLine($" Room: {room}"); builder.AppendLine($" Report: {MessagePackObjectFormatter.Format(deserializedReport)}"); return(builder.ToString()); }
/// <summary> /// Initialize new sintance with unpacked data. /// </summary> /// <param name="rpcError"> /// Metadata of error. If you specify null, <see cref="MsgPack.Rpc.RpcError.RemoteRuntimeError"/> is used. /// </param> /// <param name="unpackedException"> /// Exception data from remote MessagePack-RPC server. /// </param> /// <exception cref="SerializationException"> /// Cannot deserialize instance from <paramref name="unpackedException"/>. /// </exception> protected internal RpcException( RpcError rpcError, MessagePackObject unpackedException ) : this(rpcError, GetString( unpackedException, MessageKeyUtf8, true ), GetString( unpackedException, DebugInformationKeyUtf8, false )) { IList<MessagePackObject> array; if ( MessagePackObjectDictionary.TryGetArray( unpackedException, _remoteExceptionsUtf8, null, out array ) ) { try { this._remoteExceptions = new RemoteExceptionInformation[ array.Count ]; for ( int i = 0; i < this._remoteExceptions.Length; i++ ) { this._remoteExceptions[ i ] = new RemoteExceptionInformation( array[ i ].AsList() ); } } catch ( InvalidOperationException ex ) { throw new SerializationException( "Failed to deserialize remote exception information", ex ); } } }
public void UnpackFromMessage( MessagePackObject messagePackObject ) { if (! messagePackObject.IsTypeOf<IList<MessagePackObject>>().GetValueOrDefault() ) { throw new ArgumentException(messagePackObject.UnderlyingType.ToString()); } var asList = messagePackObject.AsList(); if ( asList.Count != 5 ) { throw new ArgumentException(); } uri = asList[ 0 ].AsString(); title = asList[ 1].AsString(); width = asList[ 2 ].AsInt32(); height = asList[ 3 ].AsInt32(); size = asList[ 4 ].AsInt32(); }
private static void PackValuesAsMap( Packer packer, MessagePackObject memberDefault, MessagePackObject nullButValueType, MessagePackObject nullAndNullableValueType, MessagePackObject nullAndReferenceType, MessagePackObject prohibitReferenceType ) { packer.PackMapHeader( 5 ); packer.PackString( "MemberDefault" ); packer.Pack( memberDefault ); packer.PackString( "NullButValueType" ); packer.Pack( nullButValueType ); packer.PackString( "NullAndNullableValueType" ); packer.Pack( nullAndNullableValueType ); packer.PackString( "NullAndReferenceType" ); packer.Pack( nullAndReferenceType ); packer.PackString( "ProhibitReferenceType" ); packer.Pack( prohibitReferenceType ); }
public void TestKnownErrors_Properties_ToException_ToString_GetHashCode_Success() { foreach ( var prop in typeof( RpcError ).GetProperties( BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic ).Where( item => item.PropertyType == typeof( RpcError ) ) ) { var target = prop.GetValue( null, null ) as RpcError; Assert.That( target, Is.Not.Null, prop.Name ); Assert.That( target.DefaultMessage, Is.Not.Null.And.Not.Empty, prop.Name ); Assert.That( target.DefaultMessageInvariant, Is.Not.Null.And.Not.Empty, prop.Name ); Assert.That( target.Identifier, Is.Not.Null.And.Not.Empty, prop.Name ); Assert.That( target.GetHashCode(), Is.EqualTo( target.ErrorCode ), prop.Name ); Assert.That( target.ToString(), Is.Not.Null .And.StringContaining( target.Identifier ) .And.StringContaining( target.ErrorCode.ToString( CultureInfo.CurrentCulture ) ) .And.StringContaining( target.DefaultMessage ), prop.Name ); var message = Guid.NewGuid().ToString(); var debugInformation = Guid.NewGuid().ToString(); var detail = new MessagePackObject( new MessagePackObjectDictionary() { { RpcException.MessageKeyUtf8, message }, { RpcException.DebugInformationKeyUtf8, debugInformation }, { RpcArgumentException.ParameterNameKeyUtf8, "test" }, { RpcMethodInvocationException.MethodNameKeyUtf8, "Test" }, { RpcTimeoutException.ClientTimeoutKeyUtf8, TimeSpan.FromSeconds( 15 ).Ticks } } ); var exception = target.ToException( detail ); Assert.That( exception, Is.Not.Null, prop.Name ); Assert.That( exception.DebugInformation, Is.StringContaining( debugInformation ), prop.Name ); Assert.That( exception.Message, Is.StringContaining( message ), prop.Name ); Assert.That( exception.RpcError, Is.EqualTo( target ), prop.Name ); } }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { if (arguments.Count() != 3) { return false; } uint arg1 = arguments[1].AsUInt32(); int toPlayfield = arguments[2].AsInt32(); byte destinationIndex = (byte)(arg1 >> 16); PlayfieldData pfd = PlayfieldLoader.PFData[toPlayfield]; PlayfieldDestination pfDestination = pfd.Destinations[destinationIndex]; float newX = (pfDestination.EndX - pfDestination.StartX) * 0.5f + pfDestination.StartX; float newZ = (pfDestination.EndZ - pfDestination.StartZ) * 0.5f + pfDestination.StartZ; float dist = WallCollision.Distance( pfDestination.StartX, pfDestination.StartZ, pfDestination.EndX, pfDestination.EndZ); float headDistX = (pfDestination.EndX - pfDestination.StartX) / dist; float headDistZ = (pfDestination.EndZ - pfDestination.StartZ) / dist; newX -= headDistZ * 4; newZ += headDistX * 4; Coordinate destCoordinate = new Coordinate(newX, pfDestination.EndY, newZ); ((ICharacter)self).Teleport( destCoordinate, ((ICharacter)self).Heading, new Identity() { Type = IdentityType.Playfield, Instance = toPlayfield }); return true; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, INamedEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { var temp = new UploadedNano() { NanoId = arguments[0].AsInt32() }; ((Character)self).UploadedNanos.Add(temp); UploadedNanosDao.WriteNano(((Character)self).Identity.Instance, temp); var message = new CharacterActionMessage() { Identity = self.Identity, Action = CharacterActionType.UploadNano, Target = self.Identity, Parameter1 = (int)IdentityType.NanoProgram, Parameter2 = temp.NanoId, Unknown = 0 }; ((Character)self).Client.SendCompressed(message); return true; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, INamedEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { string text = arguments[0].AsString(); byte b = 0; var message = new FormatFeedbackMessage() { Identity = self.Identity, Message = text + (char)b, Unknown1 = 0, DataLength = (short)(text.Length + 0xf), Unknown2 = 0x7e26, Unknown3 = 0x21212122, Unknown4 = 0x3a212121, Unknown5 = 0x293C, Unknown6 = 0x73, Unknown7 = 0 }; ((ICharacter)self).Send(message); return true; }
public void Reply( int? id, MessagePackObject message ) { if ( id == null ) { throw new ArgumentException( "id must be set.", "id" ); } if ( this._context.AcceptSocket == null ) { throw new InvalidOperationException(); } using ( var buffer = GCChunkBuffer.CreateDefault() ) { using ( RpcOutputBuffer rpcBuffer = SerializationUtility.SerializeResponse( id.Value, message ) ) { var bytesToSend = rpcBuffer.ReadBytes().ToArray(); this._context.AcceptSocket.Send( bytesToSend ); } } }
private static void TestEqualsCore( MessagePackObject left, MessagePackObject right, bool expected ) { Assert.AreEqual( expected, left.Equals( right ), "{0}=={1}", left.DebugDump(), right.DebugDump() ); }
private static void AssertNotEquals( MessagePackObject left, MessagePackObject right ) { TestEqualsCore( left, right, false ); }
public void TestEquals_EmptyMap_Null_False() { var target = new MessagePackObject( new MessagePackObjectDictionary( 0 ) ); Assert.IsFalse( target.Equals( default( object ) ) ); }
public void TestEquals_Map_Raw_False() { var target = new MessagePackObject( new MessagePackObjectDictionary { { "A", "A" }, { "B", "B" }, { "C", "C" } } ); var other = new MessagePackObject( "ABC" ); Assert.IsFalse( target.Equals( other ) ); }
public void TestEquals_EmptyMap_Empty_True() { var target = new MessagePackObject( new MessagePackObjectDictionary( 0 ) ); Assert.IsTrue( target.Equals( new MessagePackObjectDictionary( 0 ) ) ); }
public void TestEquals_Map_Null_False() { var target = new MessagePackObject( new MessagePackObjectDictionary() { { "A", 1 }, { "B", 2 }, { "C", 3 } } ); Assert.IsFalse( target.Equals( default( object ) ) ); }
public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { uint externalDoorInstance = self.Stats[StatIds.externaldoorinstance].BaseValue; int externalPlayfieldId = self.Stats[StatIds.externalplayfieldinstance].Value; StatelData door = PlayfieldLoader.PFData[externalPlayfieldId].Statels.FirstOrDefault( x => (uint)x.Identity.Instance == externalDoorInstance && (x.Identity.Type == IdentityType.Door /*|| x.Identity.Type==IdentityType.MissionEntrance*/)); if (door != null) { Vector3 v = new Vector3(door.X, door.Y, door.Z); Quaternion q = new Quaternion(door.HeadingX, door.HeadingY, door.HeadingZ, door.HeadingW); Quaternion.Normalize(q); Vector3 n = (Vector3)q.RotateVector3(Vector3.AxisZ); v.x += n.x * 2.5; v.z += n.z * 2.5; self.Playfield.Teleport( (Dynel)self, new Coordinate(v), q, new Identity() { Type = IdentityType.Playfield, Instance = externalPlayfieldId }); } return door != null; }
public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { Vendor temp = caller as Vendor; if (temp != null) { if (temp.BaseInventory.Pages[temp.BaseInventory.StandardPage].List().Count == 0) { if (temp.OriginalIdentity.Equals(Identity.None)) { } else { int id = temp.Playfield.Identity.Instance << 16 | ((temp.OriginalIdentity.Instance >> 16) & 0xff); ((ICharacter)self).Playfield.Publish( ChatTextMessageHandler.Default.CreateIM( ((ICharacter)self), "This shop has no entry in the database yet. Please enter a new entry with the id " + id.ToString() + ".")); } } else { ShopUpdateMessageHandler.Default.Send((ICharacter)self, caller, ((Vendor)caller).BaseInventory.Pages[((Vendor)caller).BaseInventory.StandardPage]); } } return true; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, IEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { BankMessageHandler.Default.Send((ICharacter)self); return true; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, INamedEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { IZoneClient client = ((ICharacter)self).Client; BankMessage bankmessage = OpenBank.Create(client); client.Character.Send(bankmessage); return true; }
/// <summary> /// </summary> /// <param name="self"> /// </param> /// <param name="caller"> /// </param> /// <param name="target"> /// </param> /// <param name="arguments"> /// </param> /// <returns> /// </returns> public override bool Execute( INamedEntity self, INamedEntity caller, IInstancedEntity target, MessagePackObject[] arguments) { lock (target) { return this.FunctionExecute(self, caller, target, arguments); } }