public void Process_WithFollowingStage()
        {
            var stage1 = ProcessingPipelineStage.Create <ProcessingPipelineTestStage>("Stage1", null);
            var stage2 = stage1.AddNextStage <ProcessingPipelineTestStage>("Stage2");

            // initialize the stages
            Assert.False(stage1.IsInitialized);
            Assert.False(stage2.IsInitialized);
            stage1.Initialize();
            Assert.True(stage1.IsInitialized);
            Assert.True(stage2.IsInitialized);

            // process a log message
            var message = MessagePool.GetUninitializedMessage();

            Assert.False(stage1.ProcessSyncWasCalled);
            Assert.False(stage2.ProcessSyncWasCalled);
            stage1.ProcessMessage(message);
            Assert.True(stage1.ProcessSyncWasCalled);
            Assert.True(stage2.ProcessSyncWasCalled);
            Assert.Same(message, stage1.MessagePassedToProcessSync);
            Assert.Same(message, stage2.MessagePassedToProcessSync);

            // shut the stages down
            stage1.Shutdown();
            Assert.False(stage1.IsInitialized);
            Assert.False(stage2.IsInitialized);
        }
예제 #2
0
        public void Process_WithFollowingStage()
        {
            var stage1 = ProcessingPipelineStage.Create <AsyncProcessingPipelineTestStage>("Stage1", null);
            var stage2 = stage1.AddNextStage <AsyncProcessingPipelineTestStage>("Stage2");

            // initialize the stages
            Assert.False(stage1.IsInitialized);
            Assert.False(stage2.IsInitialized);
            stage1.Initialize();
            Assert.True(stage1.IsInitialized);
            Assert.True(stage2.IsInitialized);

            // process a log message
            var message = MessagePool.GetUninitializedMessage();

            Assert.False(stage1.ProcessSyncWasCalled);
            Assert.False(stage2.ProcessSyncWasCalled);
            Assert.False(stage1.ProcessAsyncWasCalled);
            Assert.False(stage2.ProcessAsyncWasCalled);
            stage1.ProcessMessage(message);
            Assert.True(stage1.ProcessSyncWasCalled);
            Assert.True(stage2.ProcessSyncWasCalled);
            Assert.Same(message, stage1.MessagePassedToProcessSync);
            Assert.Same(message, stage2.MessagePassedToProcessSync);

            // give the processing threads time to call ProcessAsync()
            Thread.Sleep(500);

            Assert.True(stage1.ProcessAsyncWasCalled);
            Assert.True(stage2.ProcessAsyncWasCalled);
            Assert.Single(stage1.MessagesPassedToProcessAsync);
            Assert.Single(stage2.MessagesPassedToProcessAsync);
            Assert.Same(message, stage1.MessagesPassedToProcessAsync.First());
            Assert.Same(message, stage2.MessagesPassedToProcessAsync.First());
        }
예제 #3
0
        /// <summary>
        /// Imports all the Messages
        /// </summary>
        private static MessagePool ImportMessages(XmlDocument xml)
        {
            MessagePool pool = new MessagePool();

            ImportMessageType(xml, pool, MessageType.LOOK_AT_GIRL, Tags.MESSAGE_LOOK_AT);
            ImportMessageType(xml, pool, MessageType.PAIN_DOWN, Tags.MESSAGE_PAIN_DOWN);

            ImportMessageType(xml, pool, MessageType.PICKUP_IMPL, Tags.MESSAGE_PICKUP_IMPLEMENT);
            ImportMessageType(xml, pool, MessageType.ENTER_IMPL, Tags.MESSAGE_ENTER_WITH_IMPLEMENT);
            ImportMessageType(xml, pool, MessageType.SWAP_IMPL, Tags.MESSAGE_SWAP_IMPLEMENT);
            ImportMessageType(xml, pool, MessageType.SWAP_WORSE_IMPL, Tags.MESSAGE_SWAP_WORSE);
            ImportMessageType(xml, pool, MessageType.DROP_IMPL, Tags.MESSAGE_DROP_IMPLEMENT);

            ImportMessageType(xml, pool, MessageType.HOLDING_ANNOUNCE, Tags.MESSAGE_HOLDING_ANNOUNCE);
            ImportMessageType(xml, pool, MessageType.HOLDING_REACT_ANNOUNCE, Tags.MESSAGE_HOLDING_ANNOUNCE_REACT);
            ImportMessageType(xml, pool, MessageType.HOLDING_WATCH_ANNOUNCE, Tags.MESSAGE_HOLDING_ANNOUNCE_WATCH);
            ImportMessageType(xml, pool, MessageType.HOLDING_START, Tags.MESSAGE_HOLDING_START);
            ImportMessageType(xml, pool, MessageType.HOLDING_START_REACT, Tags.MESSAGE_HOLDING_START_REACT);
            ImportMessageType(xml, pool, MessageType.HOLDING_START_WATCH, Tags.MESSAGE_HOLDING_START_WATCH);
            ImportMessageType(xml, pool, MessageType.DRAG, Tags.MESSAGE_HOLDING_DRAG);
            ImportMessageType(xml, pool, MessageType.DRAG_REACT, Tags.MESSAGE_HOLDING_DRAG_REACT);
            ImportMessageType(xml, pool, MessageType.DRAG_WATCH, Tags.MESSAGE_HOLDING_DRAG_WATCH);
            ImportMessageType(xml, pool, MessageType.HOLDING_STOP, Tags.MESSAGE_HOLDING_STOP);
            ImportMessageType(xml, pool, MessageType.HOLDING_STOP_REACT, Tags.MESSAGE_HOLDING_STOP_REACT);
            ImportMessageType(xml, pool, MessageType.HOLDING_STOP_WITHOUT_DRAG, Tags.MESSAGE_HOLDING_STOP_WITHOUTDRAG);

            return(pool);
        }
        public void Process_Standalone(bool processSyncReturnValue)
        {
            var callback = new Callback {
                ProcessSyncCallbackReturnValue = processSyncReturnValue
            };
            var stage = ProcessingPipelineStage.Create <CallbackPipelineStage>("Callback", null);

            stage.ProcessingCallback = callback.ProcessSyncCallback;

            // initialize the stage
            Assert.False(stage.IsInitialized);
            stage.Initialize();
            Assert.True(stage.IsInitialized);

            // process a log message
            var message = MessagePool.GetUninitializedMessage();

            Assert.False(callback.ProcessSyncCallbackWasCalled);
            stage.ProcessMessage(message);
            Assert.True(callback.ProcessSyncCallbackWasCalled);
            Assert.Same(message, callback.MessagePassedToProcessSyncCallback);

            // shut the stage down
            stage.Shutdown();
            Assert.False(stage.IsInitialized);
        }
예제 #5
0
        private async Task SendPump(CancellationToken cancellation)
        {
            using (var session = this.serializerSessionPool.GetSession())
            {
                while (!cancellation.IsCancellationRequested && await this.outgoingReader.WaitToReadAsync(cancellation))
                {
                    while (this.outgoingReader.TryRead(out var item))
                    {
                        WriteMessage(item, session);
                        if (item.Body is IDisposable disposable)
                        {
                            disposable.Dispose();
                        }

                        MessagePool.Return(item);

                        session.PartialReset();

                        var flushResult = await this.connection.Output.FlushAsync(cancellation);

                        if (flushResult.IsCanceled || flushResult.IsCompleted)
                        {
                            return;
                        }
                    }
                }
            }

            void WriteMessage(Message message, SerializerSession session)
            {
                var writer = new Writer <PipeWriter>(this.connection.Output, session);

                this.messageSerializer.Serialize(ref writer, message);
            }
        }
예제 #6
0
        public override void Send(Movement movement)
        {
            OutgoingMessage msg = MessagePool.CreateMessage();

            movement.Write(msg);
            Broadcast(msg);
        }
        public override void ClientHandleMessageFromServer(NetMessageType messageType, byte[] buffer)
        {
            // if message from server to clients
            if (messageType == NetMessageType.VRBodyUpdateS2C)
            {
                var msg          = MessagePool.Get <VRBodyUpdateS2CMessage>(buffer);
                var remotePlayer = NetServices.playerManager.players.GetValueOrDefault(msg.netId);
                if (remotePlayer != null)
                {
                    var bodyData = new VRBodyUpdateData()
                    {
                        position = msg.position, //RemotePos(senderPlayer.netId, msg.position),

                        headPosition = msg.headPosition,
                        headRotation = msg.headRotation,

                        leftHandPosition = msg.leftHandPosition,
                        leftHandRotation = msg.leftHandRotation,

                        rightHandPosition = msg.rightHandPosition,
                        rightHandRotation = msg.rightHandRotation
                    };
                    (remotePlayer as NetPlayerBase).GetComponent <VRBodyUpdateSync>().HandleUpdate(bodyData);
                }

                MessagePool.Return(msg);
            }
        }
예제 #8
0
    public override void OnCreate()
    {
        base.OnCreate();
        pool = new MessagePool();

        carousel.Factory = this;
        carousel.onVisibleElementsChanged += OnVisibleElementsChanged;

        btnRequestHelp.gameObject.SetActive(ViewModel.InGuild);
        btnRequestHelp.onClick.AddListener(OnHelpRequestButtonClicked);
        btnChatTab.onValueChanged.AddListener(OnClickChatTab);
        btnIncomingTab.onValueChanged.AddListener(OnClickIncomingTab);
        btnOpenGuildDialog.onClick.AddListener(() => OpenGuildDialog(DialogGuildsViewModel.EContentCases.Join));

        _hidePos = window.anchoredPosition.x;
        InitCloseButton();
        InitInputField();

        var scenario = Use <IGuiManager>().CreateView <WaitingOpenMarketScreenScenario>();

        scenario.dialogToClose = this;
        Use <IScenarioService>().StartScenario(scenario);

        ViewModel.ShowChatMessage();
        carousel.GotoLastPackMessage();
    }
예제 #9
0
 private void Awake()
 {
     pool     = new MessagePool();
     received = new LockFreeQueue <ReferenceCountedMessage>();
     pc       = GetComponentInParent <WebRtcPeerConnection>();
     id       = -1;
 }
        public override void ServerHandleMessageFromClient(NetMessageType messageType, byte[] buffer, short clientPlayerNetId)
        {
            // if message is from a client to server
            if (messageType == NetMessageType.VRBodyUpdateC2S)
            {
                var senderPlayer = NetServices.playerManager.players.GetValueOrDefault(clientPlayerNetId);
                if (senderPlayer != null)
                {
                    // deserialize message and have the player sync script handle it further
                    var msg      = MessagePool.Get <VRBodyUpdateC2SMessage>(buffer);
                    var bodyData = new VRBodyUpdateData()
                    {
                        position = msg.position, //ServerPos(senderPlayer.netId, msg.position),

                        headPosition = msg.headPosition,
                        headRotation = msg.headRotation,

                        leftHandPosition = msg.leftHandPosition,
                        leftHandRotation = msg.leftHandRotation,

                        rightHandPosition = msg.rightHandPosition,
                        rightHandRotation = msg.rightHandRotation
                    };

                    // this smells like bad performance. but it keeps dependencies separate.
                    // perhaps instead of GetComponent<> it can be optimized via some local VRPlayerManager that handles references of VR components on all players.
                    // every new system which has dependencies on previous systems can use this paradigm: a manager with references to connect the dependency to the new system, for efficiency, without compromising the dependency.
                    // for now we use the shitty method below because there are bigger bottlenecks
                    (senderPlayer as NetPlayerBase).GetComponent <VRBodyUpdateSync>().HandleUpdate(bodyData);

                    MessagePool.Return(msg);
                }
            }
        }
예제 #11
0
        public bool DisconnectClient(AuthClient newClient)
        {
            bool       succes = false;
            AuthClient client = AuthServer.Instance.GetClients().Find(x => x.Account != null && x.Account.Id == newClient.Account.Id);

            if (client != null)
            {
                client.Disconnect();
                succes = true;
            }
            else
            {
                if (newClient.Account.LastSelectedServerId != 0)
                {
                    TransitionClient server = TransitionServer.Instance.GetServerClient(newClient.Account.LastSelectedServerId);
                    var serverData          = ServerRecord.GetWorldServer(newClient.Account.LastSelectedServerId);
                    if (server != null && server.IsConnected && serverData != null && serverData.Status != ServerStatusEnum.STARTING) // Online
                    {
                        MessagePool.SendRequest <DisconnectClientResultMessage>(server,
                                                                                new DisconnectClientRequestMessage {
                            AccountId = newClient.Account.Id,
                        },
                                                                                delegate(DisconnectClientResultMessage message) { succes = message.IsSucces; },
                                                                                delegate() { this.OnTransitionFailed(newClient); });
                    }
                    else
                    {
                        succes = false;
                    }
                }
            }

            return(succes);
        }
예제 #12
0
        /// <summary>
        /// 判断Id是否为空 有就修改没有就添加
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public bool CreateMessagePool(CreateMessagepoolInput input)
        {
            bool        result = false;
            MessagePool pool   = new MessagePool();

            pool.Id         = input.Id;
            pool.PlatForm   = input.PlatForm;
            pool.ModelName  = input.ModelName;
            pool.OrtherMsg  = input.OrtherMsg;
            pool.Operation  = input.Operation;
            pool.JsonText   = input.JsonText;
            pool.Status     = 0;
            pool.ResultText = input.ResultText;
            var resultdata = _messagePool.Insert(pool);

            if (!string.IsNullOrWhiteSpace(resultdata.ToString()))
            {
                result = true;
            }
            return(result);
            //if (true)
            //{
            //    if (input.PoolInfo.Id.HasValue)
            //    {
            //        await UpdateMessagepool(input);
            //    }
            //    else
            //    {
            //        await AddMessagePool(input);
            //    }

            //}
        }
예제 #13
0
        public void Get_should_produce_new_message()
        {
            var      pool = new MessagePool <DummyMessage>();
            IMessage d    = pool.Get();

            Assert.NotNull(d);
        }
 private void GrabController_OnGrabNothing(ControllerGrabberData controller, IHandleGrabbing grabbedObj)
 {
     if (NetServices.isNetworked && NetServices.isClient)
     {
         // spawn!
         // or if networked, ask server for permission to spawn.
         // also give spawn request feedback, and success/fail feedback... but in separate feedback class.
         var msgReq = MessagePool.Get <SpawnGrabRequestMessage>();
         msgReq.isLeft     = controller.isLeft;
         msgReq.prefabType = GetSpawnType(controller.isLeft);
         ClientNetSender.instance.Send(msgReq, UnityEngine.Networking.QosType.ReliableSequenced);
         MessagePool.Return(msgReq);
     }
     else if (!NetServices.isNetworked)
     {
         // spawn! but beware: it might get out of sync with server... so upon reconnect, all those objects must be destroyed or re-synced! :( how the f**k to do that???
         var newObj  = PrefabManager.instance.Spawn(prefabType, controller.grabPointGO.transform.position, controller.grabPointGO.transform.rotation);
         var grabber = newObj.gameObject.GetComponent <IHandleGrabbing>();
         if (grabber != null)
         {
             controller.Grab(grabber);
         }
         Debug.Log("<color=#aa6000>Spawned non-synced object</color>", newObj.gameObject);
     }
 }
        public void CheckMessagePooledError()
        {
            try
            {
                var dummyMessage = new Message("Message for testing");

                dummyMessage.ReturnToPool();

                InvalidOperationException?expectedException = null;
                try
                {
                    dummyMessage.EnsureCapacity(500);
                }
                catch (InvalidOperationException ex)
                {
                    expectedException = ex;
                }

                Assert.IsNotNull(expectedException);
            }
            finally
            {
                // Cleanup
                MessagePool.Clear();
            }
        }
예제 #16
0
        private void ProcessBusinessAlert(MessageRuleByCompany rule)
        {
            //Console.WriteLine("Entre BA");

            try
            {
                //Si se vencio el next runtime lo ejecute
                if (rule.NextRunTime != null && rule.NextRunTime > DateTime.Now)
                {
                    return;
                }


                //Sace el data set y guarda el resultado en Message Pool
                MessagePool msg = new MessagePool
                {
                    CreationDate = DateTime.Now,
                    CreatedBy    = WmsSetupValues.SystemUser
                };


                //Console.WriteLine("Get Message");
                msg.Message = GetBusinessAlertMessage(rule);

                //Console.WriteLine("Message: " + msg.Message);

                if (string.IsNullOrEmpty(msg.Message))
                {
                    return;
                }

                msg.Entity = new ClassEntity {
                    ClassEntityID = EntityID.BusinessAlert
                };
                msg.IsHtml   = rule.IsHtml;
                msg.MailFrom = rule.MailFrom;
                msg.MailTo   = rule.MailTo;
                msg.Subject  = rule.Template.Name;

                msg.AlreadySent = false;
                msg.Rule        = rule;


                //Save the record.
                //Console.WriteLine("Saving BA:");
                Factory.DaoMessagePool().Save(msg);


                //Setea el next runtime
                rule.NextRunTime = DateTime.Now.AddSeconds(rule.FrequencyNumber * rule.FrequencyType);
                rule.LastUpdate  = DateTime.Now;
                Factory.DaoMessageRuleByCompany().Update(rule);
            }
            catch (Exception ex) {
                Console.WriteLine(ex.Message);
                ExceptionMngr.WriteEvent(" BusinessAlert:" + rule.RuleName, ListValues.EventType.Fatal, ex, null,
                                         ListValues.ErrorCategory.Messages);
            }
        }
    public static MessagePool GetInstance()
    {
        if (theOnlyInstanceOfMessageBroker == null)
        {
            theOnlyInstanceOfMessageBroker = new MessagePool();
        }

        return(theOnlyInstanceOfMessageBroker);
    }
예제 #18
0
        public static void HandleCharacterCreation(CharacterCreationRequestMessage message, WorldClient client)
        {
            if (!WorldServer.Instance.IsStatus(ServerStatusEnum.ONLINE))
            {
                client.Send(new CharacterCreationResultMessage((sbyte)CharacterCreationResultEnum.ERR_NO_REASON));

                return;
            }

            if (!client.InGame)
            {
                if (client.Characters.Count() == client.Account.CharacterSlots)
                {
                    client.Send(new CharacterCreationResultMessage((sbyte)CharacterCreationResultEnum.ERR_TOO_MANY_CHARACTERS));

                    return;
                }

                if (CharacterRecord.NameExist(message.name))
                {
                    client.Send(new CharacterCreationResultMessage((sbyte)CharacterCreationResultEnum.ERR_NAME_ALREADY_EXISTS));

                    return;
                }

                if (client.Account.Role < ServerRoleEnum.Animator)
                {
                    foreach (var value in message.name)
                    {
                        if (UnauthorizedNameContent.Contains(value))
                        {
                            client.Send(new CharacterCreationResultMessage((sbyte)CharacterCreationResultEnum.ERR_INVALID_NAME));

                            return;
                        }
                    }
                }

                if (message.name.Split(null).Count() > 1)
                {
                    client.Send(new CharacterCreationResultMessage((sbyte)CharacterCreationResultEnum.ERR_INVALID_NAME));

                    return;
                }


                long nextId = CharacterRecord.Characters.DynamicPop(x => x.Id);

                MessagePool.SendRequest <OnCharacterCreationResultMessage>(TransitionServerManager.Instance.AuthServer,
                                                                           new OnCharacterCreationMessage {
                    AccountId   = client.Account.Id,
                    CharacterId = nextId,
                },
                                                                           delegate(OnCharacterCreationResultMessage result) { CreateCharacter(message, client, result.Succes, nextId); });
            }
        }
예제 #19
0
        public void Get_should_produce_same_message()
        {
            var      pool = new MessagePool <DummyMessage>();
            IMessage d    = pool.Get();

            d.Sent();
            IMessage q = pool.Get();

            Assert.AreEqual(d, q);
        }
예제 #20
0
 public MessageQueue(MessageModule module)
 {
     nodePool    = new StablePriorityQueueNodePool();
     excuteMap   = new Dictionary <StablePriorityQueueNode, Message>();
     _pool       = new MessagePool();
     _queue      = new StablePriorityQueue <StablePriorityQueueNode>();
     _list       = new List <StablePriorityQueueNode>();
     _tmp        = new Queue <Message>();
     this.module = module;
 }
        public override void ServerHandleMessageFromClient(NetMessageType messageType, byte[] buffer, short clientPlayerNetId)
        {
            switch (messageType)
            {
            case NetMessageType.Grab:
            {
                var msg    = MessagePool.Get <GrabMessage>(buffer);
                var player = NetServices.playerManager.GetPlayer(msg.netId);
                if (player != null)
                {
                    RigidbodySyncComponent rbc = RbSyncManager.instance.Get(msg.syncId);
                    if (rbc != null)
                    {
                        var grabSystem = player.gameObject.GetComponent <VRPlayerGrabSystem>();
                        var cgd        = grabSystem.GetControllerGrabberData(msg.leftHand);
                        cgd.Grab(rbc.GetComponent <IHandleGrabbing>());
                        rbc.StopUpdating(cgd.controller);

                        ServerNetSender.instance.SendToAll(msg, UnityEngine.Networking.QosType.ReliableSequenced, msg.netId);
                    }
                }
                MessagePool.Return(msg);
                break;
            }

            case NetMessageType.Throw:
            {
                var msg    = MessagePool.Get <ThrowMessage>(buffer);
                var player = NetServices.playerManager.GetPlayer(msg.netId);
                if (player != null)
                {
                    RigidbodySyncComponent rbc = RbSyncManager.instance.Get(msg.syncId);
                    if (rbc != null)
                    {
                        var grabSystem = player.gameObject.GetComponent <VRPlayerGrabSystem>();
                        var cgd        = grabSystem.GetControllerGrabberData(msg.leftHand);
                        cgd.Ungrab();
                        rbc.ContinueUpdating(cgd.controller);

                        var rb = rbc.rigidbody;
                        rb.position           = msg.position;
                        rb.rotation           = msg.rotation;
                        rb.velocity           = msg.velocity;
                        rb.maxAngularVelocity = Mathf.Max(rb.maxAngularVelocity, msg.angularVelocity.magnitude);
                        rb.angularVelocity    = msg.angularVelocity;

                        // send to clients now
                        ServerNetSender.instance.SendToAll(msg, UnityEngine.Networking.QosType.ReliableSequenced, msg.netId);
                    }
                }
                MessagePool.Return(msg);
                break;
            }
            }
        }
예제 #22
0
 /// <summary>
 /// 构造函数
 /// </summary>
 public KeepSocketClient(string id)
 {
     if (_ClientMap.ContainsKey(id))
     {
         logger.Fatal("长连接服务 ID 已存在,程序将不可使用,请联系管理员重新配置程序。");
         return;
     }
     _ClientId    = id;
     _MessagePool = new AsyncMessagePool();
     _ClientMap.Add(id, this);
 }
예제 #23
0
        public IList <MessagePool> Select(MessagePool data)
        {
            IList <MessagePool> datos = new List <MessagePool>();

            datos = GetHsql(data).List <MessagePool>();
            if (!Factory.IsTransactional)
            {
                Factory.Commit();
            }
            return(datos);
        }
        protected void OnClearClick(object sender, EventArgs e)
        {
            // add some back to message pool
            foreach (GameMessage msg in DataSource)
            {
                MessagePool.PushFree(msg);
            }

            // now clear
            DataSource.Clear();
        }
예제 #25
0
        private void Introduce(RemoteConnection remote, IPEndPoint endPoint)
        {
            Debug.Log("NATServer: Introducing: ", endPoint.ToString(), " to: ", remote.EndPoint.ToString());
            OutgoingMessage message = MessagePool.CreateMessage();

            message.Write(NATMessageType.INTRODUCTION);
            message.Write(endPoint);
            remote.Send(message);

            MessagePool.Recycle(message);
        }
예제 #26
0
        private void ProcessMessageObject(Object obj, Int32 rID, string rCode, MessageRuleByCompany rule, short EntityTypeID)
        {
            try
            {
                //lista de Mappings
                IList <LabelMapping> listMap = Factory.DaoLabelMapping().Select(
                    new LabelMapping {
                    LabelType = new DocumentType {
                        DocTypeID = LabelType.Message
                    }
                });


                if (listMap != null && listMap.Count > 0)
                {
                    MessagePool msg = GenerateMessage(listMap, rule.Template, obj);

                    if (!string.IsNullOrEmpty(rule.Template.DetailQuery))
                    {
                        msg.Message += AddDocumentDetails(rule, rID, rCode);
                    }

                    //Revisa si hay rule extension que adicionan informacion al mensaje
                    if (rule.RuleExtensions != null && rule.RuleExtensions.Count > 0)
                    {
                        msg.Message += AddRuleExtension(rule, rID);
                    }

                    //Campos Faltantes
                    msg.RecordID = rID;
                    msg.Entity   = new ClassEntity {
                        ClassEntityID = EntityTypeID
                    };
                    msg.IsHtml   = rule.IsHtml;
                    msg.MailFrom = rule.MailFrom;
                    msg.MailTo   = rule.MailTo;

                    //Si el objeto es un documento de tipo sales Shipment y esta la
                    //Variable de sent notification to customers se va el mail.
                    if (obj.GetType().Equals(typeof(Document)))
                    {
                        msg.MailTo += GetAccountAddress((Document)obj);
                    }


                    msg.AlreadySent = false;
                    msg.Rule        = rule;

                    //Save the record.
                    Factory.DaoMessagePool().Save(msg);
                }
            }
            catch { }
        }
예제 #27
0
        // Param == connection to be introduced
        public void Introduce(NATRemote conn)
        {
            Debug.Log("NATServer: Introducing: ", conn.Remote.EndPoint.ToString(), " to: ", Remote.EndPoint.ToString());
            OutgoingMessage message = MessagePool.CreateMessage();

            message.Write(NATMessageType.INTRODUCTION);
            message.Write(conn.Remote.EndPoint);

            Remote.Send(message);

            MessagePool.Recycle(message);
        }
예제 #28
0
        /// <summary>
        /// Obains a new Message for <code>TMessage</code> this can be a new Message a unused
        /// Message from the internal pool
        /// </summary>
        /// <typeparam name="TMessage">Type of data the message should wrap</typeparam>
        /// <returns>a (new) Message that can be used</returns>
        public static Message <TMessage> GetMessage <TMessage>()
        {
            Message <TMessage> message = MessagePool.GetMessage <TMessage>();

            if (message == null)
            {
                message        = new Message <TMessage>();
                message._inUse = true;
                MessagePool.AddMessage <TMessage>(message);
            }

            return(message);
        }
        public int AddMessagePool(MessagePoolDto messagePoolDto)
        {
            var messagePool = new MessagePool
            {
                iMessageID = messagePoolDto.MessageId,
                iPoolID = messagePoolDto.PoolId
            };

            Uow.MessagePools.Add(messagePool);
            Uow.Commit();

            return messagePool.iMessagePoolID;
        }
예제 #30
0
        /// <summary>
        /// Sends a message to a remote connection
        /// </summary>
        public void InformPunchthroughSuccess()
        {
            OutgoingMessage request = MessagePool.CreateMessage();

            request.Write(NATMessageType.NAT_PUNCH_SUCCESS);

            fixed(byte *bytes = request.Data)
            {
                ENet.MicroSend(Peer, 0, bytes, (IntPtr)request.ByteCount, DeliveryMethod.Reliable);
            }

            MessagePool.Recycle(request);
        }
        public void AddAndGet_OneMessage_ReturnsSameMessage()
        {
            MessagePool <StringMsg> pool = new MessagePool <StringMsg>();
            const string            firstMessageContents = "first message";
            StringMsg str1 = new StringMsg(firstMessageContents);

            pool.AddMessage(str1);
            StringMsg str2 = pool.GetOrCreateMessage();
            StringMsg str3 = pool.GetOrCreateMessage();

            Assert.AreEqual(str1, str2);
            Assert.AreNotEqual(str2, str3);
        }
예제 #32
0
 public MessageArguments(MessagePool messageCollection)
 {
     this._messageCollection = messageCollection;
 }
        /// <summary>
        /// Entry point for the application
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            // Create the message pool
            MessagePool pool = new MessagePool();

            // Create the root actor
            Actor root = new Actor(pool);

            // Attach core systems
            root.AddComponent<UserInputHandler>();
            root.AddComponent<Renderer>();
            root.AddComponent<MaterialSystem>();
            root.AddComponent<SceneManager>();
            root.AddComponent<SceneLoader>();
            root.AddComponent<Sleeper>().TargetFPS = 60.0f;

            // Attach exit listener
            bool exit = false;
            Listener<ExitMessage> exitlistener = root.AddComponent<Listener<ExitMessage>>() as Listener<ExitMessage>;
            exitlistener.OnMessageReceived += (msg) => exit = true;

            // Initialise
            root.Init();

            // Send the initialise message
            InitialiseMessage initmsg = new InitialiseMessage();
            pool.SendMessage(initmsg);

            // Load the scene
            if (!root.GetComponent<SceneLoader>().LoadSceneFromFile("scene.json"))
            {
                Console.WriteLine("Failed to load scene!");
                Console.ReadKey();
                return;
            }

            // Setup the frame message
            FrameMessage framemsg = new FrameMessage();
            framemsg.FrameNumber = 0;
            framemsg.DeltaTime = 0.0f;

            // Setup the timer
            Stopwatch frametimer = new Stopwatch();

            // Loop until done
            while (!exit)
            {
                // Send frame message
                frametimer.Start();
                pool.SendMessage(framemsg);
                frametimer.Stop();
                framemsg.DeltaTime = (float)frametimer.Elapsed.TotalSeconds;
                frametimer.Reset();

                // Increase frame number
                framemsg.FrameNumber++;

                // Process windows events
                Application.DoEvents();
            }

            // Send the shutdown message
            ShutdownMessage shutdownmsg = new ShutdownMessage();
            pool.SendMessage(shutdownmsg);

            // Delete root actor and clean up
            root.Destroy(true);
        }