private static void MapResponseResult(IInvocation invocation, List<ParameterInfo> @params, RpcResponse response)
        {
            if (response.Exception != null)
            {
                throw response.Exception;
            }

            if (invocation.Method.ReturnType != typeof(void) && response.ReturnValue != null)
            {
                invocation.ReturnValue = response.ReturnValue.ConvertToCorrectTypeValue(invocation.Method.ReturnType);
            }

            var outParams = @params.Where(x => x.IsOut).Select(x => x.Name);
            var missingOutValue = outParams.FirstOrDefault(param => !(response.ChangedParams ?? new Dictionary<string, object>()).ContainsKey(param));
            if (missingOutValue != null)
            {
                throw new Exception(string.Format("RpcResponse does not contain the modified value for param {0} which is an 'out' param. Probably there's something wrong with the bloody Coordinator", missingOutValue));
            }

            for (var i = 0; i < @params.Count; i++)
            {
                if (@params[i].IsOut)
                {
                    invocation.SetArgumentValue(i, response.ChangedParams[@params[i].Name].ConvertToCorrectTypeValue(@params[i].ParameterType.GetElementType()));
                }
                else if (@params[i].ParameterType.IsByRef && response.ChangedParams.ContainsKey(@params[i].Name))
                {
                    invocation.SetArgumentValue(i, response.ChangedParams[@params[i].Name].ConvertToCorrectTypeValue(@params[i].ParameterType.GetElementType()));
                }
            }
        }
        public void Should_return_and_log_warn_msg_if_the_waitHandlers_does_not_contain_requestId()
        {
            // Arrange
            InternalDependencies.RpcQueueHelper = Substitute.For<IRpcQueueHelper>();
            var client = new BurrowRpcClientCoordinator<ISomeService>(null, Substitute.For<IRpcRouteFinder>());

            var res = new RpcResponse
            {
                RequestId = Guid.NewGuid()
            };

            // Action
            client.ReceiveResponse(res);

            // Assert
            Global.DefaultWatcher.Received(1).WarnFormat(Arg.Any<string>(), Arg.Any<object[]>());
        }
Beispiel #3
0
        public void HandleMesage(RpcRequest msg)
        {
            if (msg.UtcExpiryTime != null && msg.UtcExpiryTime < DateTime.UtcNow)
            {
                Global.DefaultWatcher.WarnFormat("Msg {0}.{1} from {2} has been expired", msg.DeclaringType, msg.MethodName, msg.ResponseAddress);
                return;
            }

            var response = new RpcResponse
            {
                RequestId = msg.Id,
            };

            try
            {
                var methodInfo = InternalDependencies.MethodMatcher.Match <T>(msg);
                if (methodInfo == null)
                {
                    throw new Exception(string.Format("Could not find a match member of type {0} for method {1} of {2}", msg.MemberType.ToString(), msg.MethodName, msg.DeclaringType));
                }

                object[] parameters = msg.Params.Values.ToArray();
                response.ReturnValue = methodInfo.Invoke(_realInstance, parameters);
                var keys = msg.Params.Keys.ToArray();

                for (int i = 0; i < msg.Params.Count; i++)
                {
                    msg.Params[keys[i]] = parameters[i];
                }
                response.ChangedParams = msg.Params;
            }
            catch (Exception ex)
            {
                response.Exception = ex;
            }

            if (!string.IsNullOrEmpty(msg.ResponseAddress))
            {
                _tunnel.Publish(response, msg.ResponseAddress);
            }
        }
        public void Should_set_respones_value_to_wait_handler_and_set_the_wait_handler()
        {
            // Arrange
            InternalDependencies.RpcQueueHelper = Substitute.For<IRpcQueueHelper>();
            var client = new BurrowRpcClientCoordinator<ISomeService>(null, Substitute.For<IRpcRouteFinder>());

            var res = new RpcResponse
            {
                RequestId = Guid.NewGuid()
            };
            var handlers = client.GetCachedWaitHandlers();
            var wait = new RpcWaitHandler();
            handlers.TryAdd(res.RequestId, wait);

            // Action
            Task.Factory.StartNew(() => client.ReceiveResponse(res));

            // Assert
            wait.WaitHandle.WaitOne();
            Assert.AreEqual(res, wait.Response);
        }
Beispiel #5
0
        public static RpcResponse DeserializeResponse(RpcRequest request, string json)
        {
            RpcResponse response = JsonConvert.DeserializeObject <RpcResponse>(json);

            string     typename   = request.DeclaringType + "," + request.DeclaringAssembly; // = "test.ICalculator,test";
            Type       dataType   = Type.GetType(typename);                                  // request.DeclaringType);
            MethodInfo mi         = dataType.GetMethod(request.MethodName);
            Type       returnType = mi.ReturnType;

            response.ReturnValue = Sanitize(returnType, response.ReturnValue);

            /*if (response.ReturnValue.GetType() == typeof (Newtonsoft.Json.Linq.JArray)) {
             *      Newtonsoft.Json.Linq.JArray jarray = (Newtonsoft.Json.Linq.JArray) response.ReturnValue;
             *      string dataJson = jarray.ToString ();
             *
             *      var data =   JsonConvert.DeserializeObject (dataJson, returnType);
             *      response.ReturnValue = data;
             *      int j = 34;
             * }*/



            return(response);
        }
Beispiel #6
0
        private static void MapResponseResult(IInvocation invocation, List <ParameterInfo> @params, RpcResponse response)
        {
            if (response.Exception != null)
            {
                throw response.Exception;
            }

            if (invocation.Method.ReturnType != typeof(void) && response.ReturnValue != null)
            {
                invocation.ReturnValue = response.ReturnValue.ConvertToCorrectTypeValue(invocation.Method.ReturnType);
            }

            var outParams       = @params.Where(x => x.IsOut).Select(x => x.Name);
            var missingOutValue = outParams.FirstOrDefault(param => !(response.ChangedParams ?? new Dictionary <string, object>()).ContainsKey(param));

            if (missingOutValue != null)
            {
                throw new Exception(string.Format("RpcResponse does not contain the modified value for param {0} which is an 'out' param. Probably there's something wrong with the bloody Coordinator", missingOutValue));
            }

            for (var i = 0; i < @params.Count; i++)
            {
                if (@params[i].IsOut)
                {
                    invocation.SetArgumentValue(i, response.ChangedParams[@params[i].Name].ConvertToCorrectTypeValue(@params[i].ParameterType.GetElementType()));
                }
                else if (@params[i].ParameterType.IsByRef && response.ChangedParams.ContainsKey(@params[i].Name))
                {
                    invocation.SetArgumentValue(i, response.ChangedParams[@params[i].Name].ConvertToCorrectTypeValue(@params[i].ParameterType.GetElementType()));
                }
            }
        }
        public void Intercept(IInvocation invocation)
        {
            var method = invocation.Method;

            var attributes = method.GetCustomAttributes(true).Select(x => x as Attribute).ToArray();
            var isAsync    = _methodFilters.Any(filter => filter.IsAsync(method, attributes));

            _methodFilters.ForEach(filter => filter.CheckValid(method, attributes, isAsync));

            var @params = method.GetParameters().ToList();

            var args = new Dictionary <string, object>();

            for (int i = 0; i < invocation.Arguments.Length; i++)
            {
                args.Add(@params[i].Name, invocation.Arguments[i]);
            }

            var request = new RpcRequest
            {
                Params            = args,
                MemberType        = method.MemberType,
                MethodName        = method.Name,
                MethodSignature   = InternalDependencies.MethodMatcher.GetMethodSignature(method),
                DeclaringType     = method.DeclaringType.FullName,
                DeclaringAssembly = method.DeclaringType.Assembly.FullName.Substring(0, method.DeclaringType.Assembly.FullName.IndexOf(","))
            };



            var timeToLiveAttribute = attributes.LastOrDefault(x => x is RpcTimeToLiveAttribute);

            if (timeToLiveAttribute != null)
            {
                var att = (RpcTimeToLiveAttribute)timeToLiveAttribute;
                if (att.Seconds > 0)
                {
                    request.UtcExpiryTime = DateTime.UtcNow.AddSeconds(att.Seconds);
                }
            }

            string jsonRequest = JsonConvert.SerializeObject(request);

            //Console.WriteLine("Client Sending Request: {0}", jsonRequest);
            if (log != null)
            {
                log(Direction.Sent, jsonRequest);
            }
            client.SendFrame(jsonRequest);

            string jsonResponse = client.ReceiveFrameString();

            if (log != null)
            {
                log(Direction.Received, jsonResponse);
            }
            //Console.WriteLine("Client Response Received: {0}", jsonResponse);


            RpcResponse response = JSON.DeserializeResponse(request, jsonResponse);               //     JsonConvert.DeserializeObject<RpcResponse>(jsonResponse);


            MapResponseResult(invocation, @params, response);
        }