/// <summary> /// Called when a method or property call is intercepted. /// </summary> /// <param name="invocation">Information about the call that was intercepted.</param> public void Intercept(IInvocation invocation) { m_Diagnostics.Log( LevelToLog.Trace, CommunicationConstants.DefaultLogTextPrefix, string.Format( CultureInfo.InvariantCulture, "Invoking {0}", MethodToText(invocation.Method))); Task <ICommunicationMessage> result; try { var tuple = ToParameterData(invocation.Method, invocation.Arguments); result = m_TransmitCommandInvocation( new CommandInvokedData( CommandId.Create(invocation.Method), tuple.Item3), tuple.Item1, tuple.Item2); } catch (EndpointNotContactableException e) { m_Diagnostics.Log( LevelToLog.Error, CommunicationConstants.DefaultLogTextPrefix, string.Format( CultureInfo.InvariantCulture, "Tried to invoke {0}, but failed to contact the remote endpoint.", MethodToText(invocation.Method))); throw new CommandInvocationFailedException(Resources.Exceptions_Messages_CommandInvocationFailed, e); } catch (FailedToSendMessageException e) { m_Diagnostics.Log( LevelToLog.Error, CommunicationConstants.DefaultLogTextPrefix, string.Format( CultureInfo.InvariantCulture, "Tried to invoke {0}, but failed to send the message.", MethodToText(invocation.Method))); throw new CommandInvocationFailedException(Resources.Exceptions_Messages_CommandInvocationFailed, e); } invocation.ReturnValue = ExtractMethodReturnFrom(invocation, result); }
public void ToMessage() { var serializers = new Mock <IStoreObjectSerializers>(); { serializers.Setup(s => s.HasSerializerFor(It.IsAny <Type>())) .Callback <Type>(t => Assert.IsTrue(typeof(int).Equals(t))) .Returns(true); serializers.Setup(s => s.SerializerFor(It.IsAny <Type>())) .Returns(new NonTransformingObjectSerializer()); } var translator = new CommandInvocationConverter(serializers.Object); var id = CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })); var data = new CommandInvocationData { Id = new MessageId(), InResponseTo = new MessageId(), Sender = new EndpointId("a"), CommandId = CommandIdExtensions.Serialize(id), ParameterTypes = new[] { new SerializedType { FullName = typeof(int).FullName, AssemblyName = typeof(int).Assembly.GetName().Name }, }, ParameterNames = new[] { "other", }, ParameterValues = new object[] { 1, } }; var msg = translator.ToMessage(data); Assert.IsInstanceOf(typeof(CommandInvokedMessage), msg); Assert.AreSame(data.Id, msg.Id); Assert.AreSame(data.Sender, msg.Sender); Assert.AreEqual(id, ((CommandInvokedMessage)msg).Invocation.Command); Assert.AreEqual(data.ParameterTypes.Length, ((CommandInvokedMessage)msg).Invocation.Parameters.Length); Assert.AreEqual(typeof(int), ((CommandInvokedMessage)msg).Invocation.Parameters[0].Parameter.Type); Assert.AreEqual("other", ((CommandInvokedMessage)msg).Invocation.Parameters[0].Parameter.Name); Assert.AreEqual(1, ((CommandInvokedMessage)msg).Invocation.Parameters[0].Value); }
public void FromMessage() { var serializers = new Mock <IStoreObjectSerializers>(); { serializers.Setup(s => s.HasSerializerFor(It.IsAny <Type>())) .Returns(true); serializers.Setup(s => s.SerializerFor(It.IsAny <Type>())) .Returns(new NonTransformingObjectSerializer()); } var translator = new CommandInvocationConverter(serializers.Object); var id = CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })); var msg = new CommandInvokedMessage( new EndpointId("a"), new CommandInvokedData( id, new[] { new CommandParameterValueMap( new CommandParameterDefinition(typeof(object), "other", CommandParameterOrigin.FromCommand), 1), })); var data = translator.FromMessage(msg); Assert.IsInstanceOf(typeof(CommandInvocationData), data); Assert.AreSame(msg.Id, data.Id); Assert.AreSame(msg.Sender, data.Sender); Assert.AreSame(msg.InResponseTo, data.InResponseTo); Assert.AreEqual(CommandIdExtensions.Serialize(id), ((CommandInvocationData)data).CommandId); Assert.AreEqual(msg.Invocation.Parameters.Length, ((CommandInvocationData)data).ParameterTypes.Length); Assert.AreEqual( msg.Invocation.Parameters[0].Parameter.Type.FullName, ((CommandInvocationData)data).ParameterTypes[0].FullName); Assert.AreEqual( msg.Invocation.Parameters[0].Parameter.Type.Assembly.GetName().Name, ((CommandInvocationData)data).ParameterTypes[0].AssemblyName); Assert.AreEqual(msg.Invocation.Parameters.Length, ((CommandInvocationData)data).ParameterNames.Length); Assert.AreEqual( msg.Invocation.Parameters[0].Parameter.Name, ((CommandInvocationData)data).ParameterNames[0]); Assert.AreEqual(msg.Invocation.Parameters.Length, ((CommandInvocationData)data).ParameterValues.Length); Assert.AreEqual( msg.Invocation.Parameters[0].Value, ((CommandInvocationData)data).ParameterValues[0]); }
public void ProxyConnectingToMethodWithRetryCount() { var remoteEndpoint = new EndpointId("other"); var local = new EndpointId("local"); var retryCount = -1; var timeout = TimeSpan.MinValue; CommandInvokedMessage intermediateMsg = null; SendMessageAndWaitForResponse sender = (e, m, r, t) => { retryCount = r; timeout = t; intermediateMsg = m as CommandInvokedMessage; return(Task <ICommunicationMessage> .Factory.StartNew( () => new SuccessMessage(remoteEndpoint, new MessageId()), new CancellationToken(), TaskCreationOptions.None, new CurrentThreadTaskScheduler())); }; var configuration = new Mock <IConfiguration>(); { configuration.Setup(c => c.HasValueFor(It.IsAny <ConfigurationKey>())) .Returns(false); } var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var builder = new CommandProxyBuilder(local, sender, configuration.Object, systemDiagnostics); var proxy = builder.ProxyConnectingTo <InteractionExtensionsTest.IMockCommandSetWithTaskReturn>(remoteEndpoint); var result = proxy.MyRetryMethod(10); result.Wait(); Assert.IsTrue(result.IsCompleted); Assert.IsFalse(result.IsCanceled); Assert.IsFalse(result.IsFaulted); Assert.AreEqual( CommandId.Create(typeof(InteractionExtensionsTest.IMockCommandSetWithTaskReturn).GetMethod("MyRetryMethod")), intermediateMsg.Invocation.Command); Assert.AreEqual(0, intermediateMsg.Invocation.Parameters.Length); Assert.AreEqual(10, retryCount); Assert.AreEqual(TimeSpan.FromMilliseconds(CommunicationConstants.DefaultWaitForResponseTimeoutInMilliSeconds), timeout); }
public void Create() { var id = new EndpointId("sendingEndpoint"); var commandId = CommandId.Create(typeof(int).GetMethod("CompareTo", new[] { typeof(object) })); var invocationData = new CommandInvokedData( commandId, new[] { new CommandParameterValueMap( new CommandParameterDefinition(typeof(int), "other", CommandParameterOrigin.FromCommand), 1.0), }); var msg = new CommandInvokedMessage(id, invocationData); Assert.AreSame(id, msg.Sender); Assert.AreSame(invocationData, msg.Invocation); }
public void ProxyConnectingToMethodWithTypedTaskReturnWithFailedExecution() { var remoteEndpoint = new EndpointId("other"); var local = new EndpointId("local"); CommandInvokedMessage intermediateMsg = null; SendMessageAndWaitForResponse sender = (e, m, r, t) => { intermediateMsg = m as CommandInvokedMessage; return(Task <ICommunicationMessage> .Factory.StartNew( () => new FailureMessage(remoteEndpoint, new MessageId()), new CancellationToken(), TaskCreationOptions.None, new CurrentThreadTaskScheduler())); }; var configuration = new Mock <IConfiguration>(); { configuration.Setup(c => c.HasValueFor(It.IsAny <ConfigurationKey>())) .Returns(false); } var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var builder = new CommandProxyBuilder(local, sender, configuration.Object, systemDiagnostics); var proxy = builder.ProxyConnectingTo <InteractionExtensionsTest.IMockCommandSetWithTypedTaskReturn>(remoteEndpoint); var result = proxy.MyMethod(10); Assert.Throws <AggregateException>(result.Wait); Assert.IsTrue(result.IsCompleted); Assert.IsFalse(result.IsCanceled); Assert.IsTrue(result.IsFaulted); Assert.IsAssignableFrom(typeof(CommandInvocationFailedException), result.Exception.InnerExceptions[0]); Assert.AreEqual( CommandId.Create(typeof(InteractionExtensionsTest.IMockCommandSetWithTypedTaskReturn).GetMethod("MyMethod")), intermediateMsg.Invocation.Command); Assert.AreEqual(1, intermediateMsg.Invocation.Parameters.Length); Assert.AreEqual(typeof(int), intermediateMsg.Invocation.Parameters[0].Parameter.Type); Assert.AreEqual("input", intermediateMsg.Invocation.Parameters[0].Parameter.Name); Assert.AreEqual(10, intermediateMsg.Invocation.Parameters[0].Value); }
public void InvokeWithTaskReturn() { var actionObject = new Mock <IMockCommandSet>(); { actionObject.Setup(a => a.MethodWithoutReturnValue(It.IsAny <int>())) .Verifiable(); } var commandIds = new List <CommandId> { CommandId.Create(typeof(IMockCommandSet).GetMethod("MethodWithoutReturnValue")), }; var commandSets = new List <CommandDefinition> { new CommandDefinition( commandIds[0], new[] { new CommandParameterDefinition( typeof(int), "someNumber", CommandParameterOrigin.FromCommand), }, false, (Action <int>)actionObject.Object.MethodWithoutReturnValue) }; var endpoint = new EndpointId("id"); ICommunicationMessage storedMsg = null; SendMessage sendAction = (e, m, r) => { storedMsg = m; }; var commands = new Mock <ICommandCollection>(); { commands.Setup(c => c.CommandToInvoke(It.IsAny <CommandId>())) .Returns(commandSets[0]); commands.Setup(c => c.GetEnumerator()) .Returns(commandIds.GetEnumerator()); } var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var action = new CommandInvokedProcessAction(endpoint, sendAction, commands.Object, systemDiagnostics); action.Invoke( new CommandInvokedMessage( new EndpointId("otherId"), new CommandInvokedData( commandIds[0], new[] { new CommandParameterValueMap( new CommandParameterDefinition(typeof(int), "someNumber", CommandParameterOrigin.FromCommand), 2), }))); actionObject.Verify(a => a.MethodWithoutReturnValue(It.IsAny <int>()), Times.Once()); Assert.IsInstanceOf <SuccessMessage>(storedMsg); }