예제 #1
0
        public void TestSwap()
        {
            using ( var target = new RpcOutputBuffer( ChunkBuffer.CreateDefault() ) )
            {
                using ( var stream = target.OpenWriteStream() )
                {
                    stream.Write( Enumerable.Range( 1, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
                }

                using ( var swapper = target.CreateSwapper() )
                {
                    CollectionAssert.AreEqual(
                        Enumerable.Range( 1, 10 ).Select( i => ( byte )i ).ToArray(),
                        swapper.ReadBytes()
                    );

                    swapper.WriteBytes( Enumerable.Range( 11, 30 ).Select( i => ( byte )i ) );
                }

                CollectionAssert.AreEqual(
                    Enumerable.Range( 11, 30 ).Select( i => ( byte )i ).ToArray(),
                    target.ReadBytes().ToArray()
                );
            }
        }
 private ResponseMessageSerializationContext( RpcOutputBuffer buffer, int messageId, object returnValue, RpcException exception, bool isVoid )
     : base(buffer)
 {
     this._messageId = messageId;
     this._returnValue = returnValue;
     this._isVoid = isVoid;
     this._exception = exception;
 }
		private static void TestSerializeCore( int id, object returnValue, bool isVoid, RpcException error )
		{
			if ( isVoid )
			{
				Assert.IsNull( returnValue, "Return value should not be specified in void." );
			}

			if ( error != null )
			{
				Assert.IsNull( returnValue, "Return value shoud not be specified in error." );
				Assert.IsFalse( isVoid, "isVoid should be false in error test." );
			}

			// TODO: Mock filters
			var objectTracingFilter = new SerializingResponseTracingFilterProvider();
			var binaryTracingFilter = new SerializedResponseTracingFilterProvider();
			var target =
				SerializerFactory.CreateResponseMessageSerializerWithTracer(
					objectTracingFilter,
					binaryTracingFilter,
					null,
					null
				);
			try
			{
				var buffer = new RpcOutputBuffer( ChunkBuffer.CreateDefault() );

				Assert.IsTrue( target.Serialize( id, returnValue, isVoid, error, buffer ).IsSuccess );
				byte[] serialized = buffer.ReadBytes().ToArray();
				var mpo =
					new MessagePackObject(
						new MessagePackObject[]
					{
						new MessagePackObject( ( int )MessageType.Response ),
						new MessagePackObject( ( uint )id ),
						error == null ? MessagePackObject.Nil : error.RpcError.Identifier,
						returnValue == null 
							? ( error == null ? MessagePackObject.Nil : error.GetExceptionMessage( false ) )
							: MessagePackObject.FromObject( returnValue )						
					}
					);
				var stream = new MemoryStream();
				Packer.Create( stream ).Pack( mpo );
				CollectionAssert.AreEqual(
					stream.ToArray(),
					serialized,
					"Expected:{0}{1}{0}Actual:{0}{2}",
					Environment.NewLine,
					mpo,
					new Unpacker( serialized ).UnpackObject()
				);
			}
			finally
			{
				Console.WriteLine( "OBJECT TRACE:{0}", objectTracingFilter.GetTrace() );
				Console.WriteLine( "BINARY TRACE:{0}", binaryTracingFilter.GetTrace() );
			}
		}
        /// <summary>
        ///		Initialize new instance for succeeded invocation of non-void method.
        /// </summary>
        /// <param name="buffer">Buffer to be written from serializer.</param>
        /// <param name="messageId">ID of this message.</param>
        /// <param name="exception">Exception thrown from the method.</param>
        /// <param name="isVoid">If invoked method is void then true.</param>
        internal ResponseMessageSerializationContext( RpcOutputBuffer buffer, int messageId, RpcException exception, bool isVoid )
            : this(buffer, messageId, null, exception, isVoid)
        {
            if ( exception == null )
            {
                throw new ArgumentNullException( "exception" );
            }

            Contract.EndContractBlock();
        }
        /// <summary>
        ///		Initialize new instance.
        /// </summary>
        /// <param name="buffer">
        ///		Buffer to store outbound data.
        /// </param>
        /// <exception cref="ArgumentNullException">
        ///		<paramref name="buffer"/> is null.
        /// </exception>
        protected MessageSerializationContext( RpcOutputBuffer buffer )
        {
            if ( buffer == null )
            {
                throw new ArgumentNullException( "buffer" );
            }

            Contract.EndContractBlock();

            this._buffer = buffer;
        }
예제 #6
0
        public static RpcOutputBuffer SerializeNotification( String method, params object[] arguments )
        {
            RpcOutputBuffer result = new RpcOutputBuffer( ChunkBuffer.CreateDefault() );
            var error =
                new RequestMessageSerializer(
                        Arrays<IFilterProvider<RequestMessageSerializationFilter>>.Empty,
                        Arrays<IFilterProvider<SerializedMessageFilter<MessageSerializationContext>>>.Empty,
                        Arrays<IFilterProvider<SerializedMessageFilter<MessageDeserializationContext>>>.Empty,
                        Arrays<IFilterProvider<RequestMessageDeserializationFilter>>.Empty,
                        null
                ).Serialize( null, method, arguments, result );
            if ( !error.IsSuccess )
            {
                throw error.ToException();
            }

            return result;
        }
예제 #7
0
        public void TestReadWrite()
        {
            using ( var target = new RpcOutputBuffer( ChunkBuffer.CreateDefault() ) )
            {
                using ( var stream = target.OpenWriteStream() )
                {
                    stream.Write( Enumerable.Range( 1, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
                    stream.Write( Enumerable.Range( 11, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
                }

                using ( var stream = target.OpenWriteStream() )
                {
                    stream.Write( Enumerable.Range( 21, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
                }

                using ( var stream = target.OpenWriteStream() ) { }

                using ( var stream = target.OpenWriteStream() )
                {
                    stream.Write( Enumerable.Range( 31, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
                }

                using ( var stream = target.OpenWriteStream() )
                {
                    stream.Write( new byte[ 0 ], 0, 0 );
                }

                using ( var stream = target.OpenWriteStream() )
                {
                    stream.Write( Enumerable.Range( 41, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
                }

                CollectionAssert.AreEqual(
                    Enumerable.Range( 1, 50 ).Select( i => ( byte )i ).ToArray(),
                    target.ReadBytes()
                );
            }
        }
        internal RequestMessageSerializationContext( RpcOutputBuffer buffer, int? messageId, string methodName, IList<object> arguments )
            : base(buffer)
        {
            if ( methodName == null )
            {
                throw new ArgumentNullException( "methodName" );
            }

            if ( String.IsNullOrWhiteSpace( methodName ) )
            {
                throw new ArgumentException( "'methodName' cannot be empty.", "methodName" );
            }

            if ( arguments == null )
            {
                throw new ArgumentNullException( "arguments" );
            }

            Contract.EndContractBlock();

            this._messageId = messageId;
            this._methodName = methodName;
            this._arguments = arguments;
        }
 /// <summary>
 ///		Initialize new instance for succeeded invocation of void method.
 /// </summary>
 /// <param name="buffer">Buffer to be written from serializer.</param>
 /// <param name="messageId">ID of this message.</param>
 internal ResponseMessageSerializationContext( RpcOutputBuffer buffer, int messageId )
     : this(buffer, messageId, null, null, true)
 {
 }
예제 #10
0
        public void TestSwap_WriteBytesNull()
        {
            using ( var target = new RpcOutputBuffer( ChunkBuffer.CreateDefault() ) )
            {
                using ( var stream = target.OpenWriteStream() )
                {
                    stream.Write( Enumerable.Range( 1, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
                }

                using ( var swapper = target.CreateSwapper() )
                {
                    swapper.WriteBytes( null );
                }
            }
        }
예제 #11
0
        public void TestSwap_WriteBytesEmpty()
        {
            using ( var target = new RpcOutputBuffer( ChunkBuffer.CreateDefault() ) )
            {
                using ( var stream = target.OpenWriteStream() )
                {
                    stream.Write( Enumerable.Range( 1, 10 ).Select( i => ( byte )i ).ToArray(), 0, 10 );
                }

                using ( var swapper = target.CreateSwapper() )
                {
                    swapper.WriteBytes( Enumerable.Empty<byte>() );
                }

                Assert.AreEqual( 0, target.ReadBytes().Count() );
            }
        }
 public void TestSerialize_Request()
 {
     // TODO: Mock filters
     var objectTracingFilter = new SerializingRequestTracingFilterProvider();
     var binaryTracingFilter = new SerializedRequestTracingFilterProvider();
     var target =
         SerializerFactory.CreateRequestMessageSerializerWithTracer(
             objectTracingFilter,
             binaryTracingFilter,
             null,
             null
         );
     try
     {
         var id = Environment.TickCount;
         var method = Guid.NewGuid().ToString();
         var args = new object[] { 1, "String", null, true };
         var buffer = new RpcOutputBuffer( ChunkBuffer.CreateDefault() );
         Assert.IsTrue( target.Serialize( id, method, args, buffer ).IsSuccess );
         byte[] serialized = buffer.ReadBytes().ToArray();
         var mpo =
             new MessagePackObject(
                 new MessagePackObject[]
                 {
                     new MessagePackObject( ( int )MessageType.Request ),
                     new MessagePackObject( ( uint )id ),
                     new MessagePackObject( method ),
                     new MessagePackObject[]
                     {
                         new MessagePackObject( 1 ),
                         new MessagePackObject( "String" ),
                         MessagePackObject.Nil,
                         new MessagePackObject( true )
                     }
                 }
             );
         var stream = new MemoryStream();
         Packer.Create( stream ).Pack( mpo );
         CollectionAssert.AreEqual( stream.ToArray(), serialized );
     }
     finally
     {
         Console.WriteLine( "OBJECT TRACE:{0}", objectTracingFilter.GetTrace() );
         Console.WriteLine( "BINARY TRACE:{0}", binaryTracingFilter.GetTrace() );
     }
 }
        /// <summary>
        ///		Serialize RPC call to specified buffer.
        /// </summary>
        /// <param name="messageId">ID of message. If message is notification message, specify null.</param>
        /// <param name="method">Method name to be called.</param>
        /// <param name="arguments">Arguments of method call.</param>
        /// <param name="buffer">Buffer to be set serialized stream.</param>
        /// <returns>Error message of serialization.</returns>
        /// <exception cref="ArgumentNullException">
        ///		<paramref name="method"/>, <paramref name="arguments"/>, or <paramref name="buffer"/> is null.
        /// </exception>
        /// <exception cref="ArgumentException">
        ///		<paramref name="method"/> is illegal.
        /// </exception>
        public RpcErrorMessage Serialize( int? messageId, string method, IList<object> arguments, RpcOutputBuffer buffer )
        {
            if ( method == null )
            {
                throw new ArgumentNullException( "method" );
            }

            // TODO: more strict validation.
            if ( String.IsNullOrWhiteSpace( method ) )
            {
                throw new ArgumentException( "'method' must not be empty nor blank.", "method" );
            }

            if ( arguments == null )
            {
                throw new ArgumentNullException( "arguments" );
            }

            if ( buffer == null )
            {
                throw new ArgumentNullException( "buffer" );
            }

            Contract.EndContractBlock();

            var context = new RequestMessageSerializationContext( buffer, messageId, method, arguments );

            foreach ( var preSerializationFilter in this._preSerializationFilters )
            {
                preSerializationFilter.GetFilter().Process( context );
                if ( !context.SerializationError.IsSuccess )
                {
                    return context.SerializationError;
                }
            }

            SerializeCore( buffer, messageId, context );
            if ( !context.SerializationError.IsSuccess )
            {
                return context.SerializationError;
            }

            foreach ( var postSerializationFilter in this._postSerializationFilters )
            {
                using ( var swapper = buffer.CreateSwapper() )
                {
                    swapper.WriteBytes( postSerializationFilter.GetFilter().Process( swapper.ReadBytes(), context ) );
                    if ( !context.SerializationError.IsSuccess )
                    {
                        return context.SerializationError;
                    }
                }
            }

            return RpcErrorMessage.Success;
        }
        private static void SerializeCore( RpcOutputBuffer buffer, int? messageId, RequestMessageSerializationContext context )
        {
            using ( var stream = buffer.OpenWriteStream() )
            using ( var packer = Packer.Create( stream ) )
            {
                packer.PackArrayHeader( messageId == null ? 3 : 4 );
                packer.Pack( ( int )( messageId == null ? MessageType.Notification : MessageType.Request ) );

                if ( messageId != null )
                {
                    packer.Pack( unchecked( ( uint )messageId.Value ) );
                }

                packer.PackString( context.MethodName );
                packer.PackItems( context.Arguments );
            }
        }
        /// <summary>
        ///		Serialize response message to specified buffer.
        /// </summary>
        /// <param name="messageId">ID of message.</param>
        /// <param name="returnValue">Return value of the method.</param>
        /// <param name="isVoid">If the method is void, then true.</param>
        /// <param name="exception">Exception thrown from the method.</param>
        /// <param name="buffer">Buffer to be stored serialized response stream.</param>
        /// <returns>Error information.</returns>
        public RpcErrorMessage Serialize( int messageId, object returnValue, bool isVoid, RpcException exception, RpcOutputBuffer buffer )
        {
            var context =
                exception != null
                ? new ResponseMessageSerializationContext( buffer, messageId, exception, isVoid )
                : ( isVoid ? new ResponseMessageSerializationContext( buffer, messageId ) : new ResponseMessageSerializationContext( buffer, messageId, returnValue ) );

            foreach ( var preSerializationFilter in this._preSerializationFilters )
            {
                preSerializationFilter.GetFilter().Process( context );
                if ( !context.SerializationError.IsSuccess )
                {
                    return context.SerializationError;
                }
            }

            SerializeCore( MessageType.Response, messageId, context );
            if ( !context.SerializationError.IsSuccess )
            {
                return context.SerializationError;
            }

            foreach ( var postSerializationFilter in this._postSerializationFilters )
            {
                using ( var swapper = buffer.CreateSwapper() )
                {
                    swapper.WriteBytes( postSerializationFilter.GetFilter().Process( swapper.ReadBytes(), context ) );
                    if ( !context.SerializationError.IsSuccess )
                    {
                        return context.SerializationError;
                    }
                }
            }

            return RpcErrorMessage.Success;
        }
예제 #16
0
 public RpcOutputBufferSwapper( RpcOutputBuffer enclosing )
 {
     Contract.Assert( enclosing != null );
     this._enclosing = enclosing;
 }
예제 #17
0
        public static RpcOutputBuffer SerializeResponse( int messageId, RpcException exception )
        {
            var result = new RpcOutputBuffer( ChunkBuffer.CreateDefault() );
            var error =
                new ResponseMessageSerializer(
                        Arrays<IFilterProvider<ResponseMessageSerializationFilter>>.Empty,
                        Arrays<IFilterProvider<SerializedMessageFilter<MessageSerializationContext>>>.Empty,
                        Arrays<IFilterProvider<SerializedMessageFilter<MessageDeserializationContext>>>.Empty,
                        Arrays<IFilterProvider<ResponseMessageDeserializationFilter>>.Empty,
                        null
                ).Serialize( messageId, null, false, exception, result );
            if ( !error.IsSuccess )
            {
                throw error.ToException();
            }

            return result;
        }
예제 #18
0
        protected override sealed void SendCore( RpcServerSession session, MessageType messageType, int messageId, object returnValue, bool isVoid, Exception exception )
        {
            RpcException rpcException = exception as RpcException;
            if ( rpcException == null && exception != null )
            {
                rpcException = new RpcException( RpcError.CallError, "Remote method throws exception.", exception.ToString() );
            }

            // FIXME: Buffer strategy
            RpcOutputBuffer buffer = new RpcOutputBuffer( ChunkBuffer.CreateDefault() );
            var error = this._responseSerializer.Serialize( messageId, returnValue, isVoid, rpcException, buffer );
            if ( !error.IsSuccess )
            {
                this._eventLoop.HandleError( new RpcTransportErrorEventArgs( RpcTransportOperation.Deserialize, messageId, error ) );
                return;
            }

            this._eventLoop.SendAsync( session.Context, buffer.ReadBytes() );
        }
 /// <summary>
 ///		Initialize new instance for succeeded invocation of non-void method.
 /// </summary>
 /// <param name="buffer">Buffer to be written from serializer.</param>
 /// <param name="messageId">ID of this message.</param>
 /// <param name="returnValue">Return value returned from the method.</param>
 internal ResponseMessageSerializationContext( RpcOutputBuffer buffer, int messageId, object returnValue )
     : this(buffer, messageId, returnValue, null, false)
 {
 }