Exemplo n.º 1
0
        public void ChekMessageTestHalloMessage()
        {
            if (!MessageQueue.Exists(@".\private$\ChekMessageTestReceiveHalloMessage"))
            {
                MessageQueue.Create(@".\private$\ChekMessageTestReceiveHalloMessage");
            }

            MessageQueue testQueue = new MessageQueue(@".\private$\ChekMessageTestReceiveHalloMessage");

            testQueue.Formatter = new BinaryMessageFormatter();

            SystemInformation info = new SystemInformation();

            HalloMessage testMessage = new HalloMessage(0, 0, info);

            testQueue.Send(testMessage);

            Thread testThread = new Thread(testChekMessageReceiveHalloMessage);

            testThread.Start();

            Assert.AreEqual(ProcessingMessage.ChekMessage(testQueue), (int)EnumTypeMessage.HelloMessage);

            MessageQueue.Delete(@".\private$\ChekMessageTestReceiveHalloMessage");
            MessageQueue.Delete(@".\private$\secondrecive1");
            MessageQueue.Delete(@".\private$\secondsend1");
        }
Exemplo n.º 2
0
        /// <summary>
        /// Функция ждет когда управляющее приложение отправит сообщение с именем очереди
        /// и присвоенным id агенту, подключается к этой очереди
        /// </summary>
        /// <returns>
        /// true если подключиться получилось, false если иначе
        /// </returns>
        public static bool Connecting(string nameQueue)
        {
            Console.WriteLine("Ожидание связи с управляющим приложнием...");
            do
            {
                Agent.mainQuere = new MessageQueue(nameQueue);
                Thread.Sleep(1000);
            } while (!Agent.mainQuere.CanRead);

            Console.WriteLine("Соединение установлено!");

            HalloMessage messagSend = new HalloMessage(0, Agent.IdAgent, Agent.Info);

            try
            {
                Agent.mainQuere.Formatter = new BinaryMessageFormatter();
                Agent.mainQuere.Send(messagSend);

                var objMessage = Agent.mainQuere.Receive();
                while (((Communication.Message)objMessage.Body).TypeMessage != (int)EnumTypeMessage.CreateQuereMessage)
                {
                    Communication.Message tempMessage = new Communication.Message(0, Agent.IdAgent);
                    tempMessage = (Communication.Message)objMessage.Body;
                    Agent.mainQuere.Send(tempMessage);

                    Thread.Sleep(1000);
                    objMessage = Agent.mainQuere.Receive();
                }

                CreateQuereMessage messageRead = (CreateQuereMessage)objMessage.Body;

                Agent.IdAgent          = messageRead.IdRecepient;
                Agent.NameQueueReceive = messageRead.PathReceive;
                Agent.NameQueueSend    = messageRead.PathSend;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return(false);
            }

            Agent.QueueReceive           = new MessageQueue("FormatName:DIRECT=OS:" + Agent.NameQueueReceive);
            Agent.QueueReceive.Formatter = new BinaryMessageFormatter();

            Agent.QueueSend           = new MessageQueue("FormatName:DIRECT=OS:" + Agent.NameQueueSend);
            Agent.QueueSend.Formatter = new BinaryMessageFormatter();

            Agent.QueueSend.Send(messagSend);

            return(true);
        }
        /// <summary>
        /// обработчик HalloMessage сообщения
        /// </summary>
        /// <param name="quere">очередь откуда пришло сообщение</param>
        /// <param name="message">приянтое сообщение</param>
        public static bool ProcessingHelloMessage(MessageQueue quere, HalloMessage message)
        {
            try
            {
                Agent agent = new Agent(_nextIdAgent, message.Info, Environment.MachineName + @"\private$\secondSend" + _nextIdAgent.ToString(), Environment.MachineName + @"\private$\secondRecive" + _nextIdAgent.ToString());

                if (!MessageQueue.Exists(agent.QueueSendName))
                {
                    MessageQueue.Create(agent.QueueSendName);
                }

                if (!MessageQueue.Exists(agent.QueueReceiveName))
                {
                    MessageQueue.Create(agent.QueueReceiveName);
                }
                agent.SetConnect();

                agent.QueueReceive.SetPermissions("АНОНИМНЫЙ ВХОД", MessageQueueAccessRights.FullControl, AccessControlEntryType.Allow);
                agent.QueueSend.SetPermissions("АНОНИМНЫЙ ВХОД", MessageQueueAccessRights.FullControl, AccessControlEntryType.Allow);

                CreateQuereMessage messageSend = new CreateQuereMessage(_nextIdAgent, 0, agent.QueueSendName, agent.QueueReceiveName);
                ++_nextIdAgent;
                quere.Send(messageSend);

                quereList.Add(agent.QueueSendName);
                quereList.Add(agent.QueueReceiveName);

                agent.QueueSend.Receive();
                agentsList.Add(agent);

                Thread threadWorkingAgent = new Thread(agent.WorkingAgent);
                Thread threadPingAgent    = new Thread(agent.PingAgent);
                threadWorkingAgent.Start();
                threadPingAgent.Start();

                Thread[] arrayThread = new Thread[2] {
                    threadWorkingAgent, threadPingAgent
                };

                dictionaryThread.Add(agent, arrayThread);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return(false);
            }
            return(true);
        }
        /// <summary>
        /// Функция ждет когда управляющее приложение отправит сообщение с именем очереди
        /// и присвоенным id агенту, подключается к этой очереди
        /// </summary>
        /// <returns>
        /// true если подключиться получилось, false если иначе
        /// </returns>
        public static bool Connecting()
        {
            while (!MessageQueue.Exists(@".\private$\MainQueue"))
            {
                System.Threading.Thread.Sleep(1000);
                Console.WriteLine("Ожидание связи с управляющим приложнием");
            }

            try
            {
                _mainQuere.Formatter = new BinaryMessageFormatter();

                HalloMessage messagSend = new HalloMessage(0, _idAgent, _info);
                _mainQuere.Send(messagSend);

                var objMessage = _mainQuere.Receive();
                while (((Communication.Message)objMessage.Body).TypeMessage != "CreateQuereMessage")
                {
                    _mainQuere.Send(messagSend);
                    Thread.Sleep(5000);
                    objMessage = _mainQuere.Receive();
                }

                CreateQuereMessage messageRead = (CreateQuereMessage)objMessage.Body;

                _idAgent          = messageRead.IdRecepient;
                _nameQueueReceive = messageRead.PathReceive;
                _nameQueueSend    = messageRead.PathSend;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return(false);
            }

            _queueReceive           = new MessageQueue(_nameQueueReceive);
            _queueReceive.Formatter = new BinaryMessageFormatter();

            _queueSend           = new MessageQueue(_nameQueueSend);
            _queueSend.Formatter = new BinaryMessageFormatter();

            return(true);
        }