コード例 #1
0
        public static Either <string, object> IsMessageValidForProcess(object message, Type[] inboxDeclaredType)
        {
            if (message == null)
            {
                return(Left <string, object>("Message invalid (null)"));
            }
            var result = IsMessageValidForProcess(message.GetType(), inboxDeclaredType);

            if (result.IsRight && result.Lift())
            {
                return(result.Map(_ => message));
            }
            else
            {
                if (message is string)
                {
                    foreach (var type in inboxDeclaredType)
                    {
                        var value = Deserialise.Object((string)message, type);
                        if (value != null)
                        {
                            return(Right <string, object>(value));
                        }
                    }
                    return(Left <string, object>("Message-type (" + message.GetType().FullName + ") is string, but couldn't convert it to any inbox supported type: " + String.Join(", ", inboxDeclaredType.Map(x => x.FullName))));
                }
                else
                {
                    return(Left <string, object>("Message-type (" + message.GetType().FullName + ") doesn't match inbox declared type: " + String.Join(", ", inboxDeclaredType.Map(x => x.FullName))));
                }
            }
        }
コード例 #2
0
        static S ProxyMsgInbox <S>(S process, ProxyMsg msg)
        {
            var types  = msg.ArgTypes.Map(Type.GetType).ToArray();
            var args   = msg.Args.Map((i, x) => Deserialise.Object(x, types[i])).ToArray();
            var method = process.GetType().GetMethod(msg.Method, types);

            var result = method.Invoke(process, args);

            if (msg.ReturnType != "System.Void" && notnull(result))
            {
                replyOrTellSender(result);
            }
            return(process);
        }
コード例 #3
0
        private static object DeserialiseMsgContent(RemoteMessageDTO msg)
        {
            object content = null;

            if (msg.Content == null)
            {
                throw new Exception($"Message content is null from {msg.Sender}");
            }
            else
            {
                var contentType = Type.GetType(msg.ContentType);
                if (contentType == null)
                {
                    throw new Exception($"Can't resolve type: {msg.ContentType}");
                }

                content = Deserialise.Object(msg.Content, contentType);
            }

            return(content);
        }
コード例 #4
0
        public static Tuple <long, Dictionary <long, AskActorReq> > Inbox(Tuple <long, Dictionary <long, AskActorReq> > state, object msg)
        {
            var reqId = state.Item1;
            var dict  = state.Item2;

            if (msg is AskActorReq)
            {
                reqId++;

                var req = (AskActorReq)msg;
                ActorContext.System(req.To).Ask(req.To, new ActorRequest(req.Message, req.To, Self, reqId), Self);
                dict.Add(reqId, req);
            }
            else
            {
                var res = (ActorResponse)msg;
                if (dict.ContainsKey(res.RequestId))
                {
                    var req = dict[res.RequestId];
                    try
                    {
                        if (res.IsFaulted)
                        {
                            Exception ex = null;

                            // Let's be reeeally safe here and do everything we can to get some valid information out of
                            // the response to report to the process doing the 'ask'.
                            try
                            {
                                var msgtype = Type.GetType(res.ResponseMessageType);
                                if (msgtype == res.Message.GetType() && typeof(Exception).GetTypeInfo().IsAssignableFrom(msgtype.GetTypeInfo()))
                                {
                                    // Type is fine, just return it as an error
                                    ex = (Exception)res.Message;
                                }
                                else
                                {
                                    if (res.Message is string)
                                    {
                                        ex = (Exception)Deserialise.Object(res.Message.ToString(), msgtype);
                                    }
                                    else
                                    {
                                        ex = (Exception)Deserialise.Object(JsonConvert.SerializeObject(res.Message), msgtype);
                                    }
                                }
                            }
                            catch
                            {
                                ex = new Exception(res.Message == null ? $"An unknown error was thrown by {req.To}" : res.Message.ToString());
                            }

                            req.Complete(new AskActorRes(new ProcessException($"Process issue: {ex.Message}", req.To.Path, req.ReplyTo.Path, ex)));
                        }
                        else
                        {
                            req.Complete(new AskActorRes(res.Message));
                        }
                    }
                    catch (Exception e)
                    {
                        req.Complete(new AskActorRes(new ProcessException($"Process issue: {e.Message}", req.To.Path, req.ReplyTo.Path, e)));
                        logSysErr(e);
                    }
                    finally
                    {
                        dict.Remove(res.RequestId);
                    }
                }
                else
                {
                    logWarn($"Request ID doesn't exist: {res.RequestId}");
                }
            }

            return(new Tuple <long, Dictionary <long, AskActorReq> >(reqId, dict));
        }