Exemplo n.º 1
0
        static void ConsumerInit(string ipPort, string topic)
        {
            if (string.IsNullOrEmpty(ipPort)) ipPort = "127.0.0.1:39654";
            QClient consumer = new QClient("subscriber-" + Guid.NewGuid().ToString("N"), ipPort);
            consumer.OnMessage += Subscriber_OnMessage;
            consumer.OnDisconnected += Client_OnDisconnected;
            consumer.ConnectAsync((s) =>
            {
                TaskHelper.LongRunning(() =>
                {
                    var old = 0;
                    var speed = 0;
                    while (consumer.Connected)
                    {
                        speed = _outNum - old;
                        old = _outNum;
                        ConsoleHelper.WriteLine("消费者已成功接收:{0} 速度:{1}/s", _outNum, speed);
                        Thread.Sleep(1000);
                    }
                });

                consumer.Subscribe(topic);
            });

        }
Exemplo n.º 2
0
        void QReader_QReadEvents(object sender, ReceiveCompletedEventArgs e)
        {
            QMessage _qmessage = e.Message.Body as QMessage;

            QClient _client  = new QClient(_qmessage);
            string  _command = _qmessage.Command.ToLower();

            string _message = _qmessage.Message;

            if (_qmessage.UsePackage == true)
            {
                _message = Serialization.SNG.ReadPackage <string>(_qmessage.Package);
            }

            if (Environment.UserInteractive == true)
            {
                if (e.Message.Label != "CFG")
                {
                    ISigner.WriteDebug(String.Format("READ: '{0}', {1}, {2}, {3}, {4}, {5}, {6}", e.Message.Label, _qmessage.Command, _qmessage.ProductId, _qmessage.pVersion, _qmessage.IpAddress, _qmessage.HostName, _message));
                }
                else
                {
                    var    _dbps        = _qmessage.Package.ToParameters();
                    string _companyId   = _dbps["companyId"].ToString();
                    string _corporateId = _dbps["corporateId"].ToString();
                    string _productId   = _dbps["productId"].ToString();
                    string _pVersion    = _dbps["pVersion"].ToString();
                    string _appkey      = _dbps["appkey"].ToString();
                    string _appvalue    = _dbps["appValue"].ToString();

                    ISigner.WriteDebug(String.Format("READ: '{0}', {1}, {2}, {3}, {4}, {5}, {6}", e.Message.Label, _companyId, _corporateId, _productId, _pVersion, _appkey, _appvalue));
                }
            }

            if (e.Message.Label == "CMD")         // command
            {
                string _product = _qmessage.ProductId;

                if (_product != ISigner.Manager.ProductId)
                {
                    if (_command == "pong")
                    {
                        QWriter.SetPingFlag(new QClient(_qmessage));
                    }
                    else if (_command == "signin")
                    {
                        QWriter.AddAgency(ISigner.Manager, _qmessage);
                    }
                    else if (_command == "signout")
                    {
                        QWriter.RemoveAgency(ISigner.Manager, new Guid(_message));
                    }
                }
            }
        }
Exemplo n.º 3
0
        static void ProducerInit(string ipPort, string topic)
        {
            int pNum = 0;

            string msg = "主要原因是由于在高并发环境下,由于来不及同步处理,请求往往会发生堵塞,比如说,大量的insert,update之类的请求同时到达MySQL,直接导致无数的行锁表锁,甚至最后请求会堆积过多,从而触发too many connections错误。通过使用消息队列,我们可以异步处理请求,从而缓解系统的压力。";

            if (string.IsNullOrEmpty(ipPort))
            {
                ipPort = "127.0.0.1:39654";
            }

            QClient producer = new QClient("productor" + Guid.NewGuid().ToString("N"), ipPort);

            producer.OnDisconnected += Client_OnDisconnected;

            producer.ConnectAsync((s) =>
            {
                Task.Factory.StartNew(() =>
                {
                    var old   = 0;
                    var speed = 0;
                    while (producer.Connected)
                    {
                        speed = pNum - old;
                        old   = pNum;
                        ConsoleHelper.WriteLine("生产者已成功发送:{0} 速度:{1}/s", pNum, speed);
                        Thread.Sleep(1000);
                    }
                });

                var list = new List <Tuple <string, byte[]> >();

                var data = Encoding.UTF8.GetBytes(msg);

                while (producer.Connected)
                {
                    producer.Publish(topic, data);

                    Interlocked.Increment(ref pNum);

                    continue;

                    list.Add(new Tuple <string, byte[]>(topic, data));

                    if (list.Count > 500)
                    {
                        producer.PublishList(list);

                        list.Clear();
                    }
                }
            });
        }
Exemplo n.º 4
0
        public void TestObserver()
        {
            Q       q  = new Q();
            QClient qc = new QClient(q);

            q.Publish("hello");
            q.Publish("hi");
            Assert.Equal("hellohi", qc.Messages);
            q.Publish("bye");
            Assert.Equal("hellohibye", qc.Messages);

            // no more message after unsubscribe
            qc.Unsubscribe();
            Assert.Equal("hellohibye", qc.Messages);
        }
Exemplo n.º 5
0
        static void ProducerInit(string ipPort, string topic)
        {
            int pNum = 0;

            //string msg = "主要原因是由于在高并发环境下,由于来不及同步处理,请求往往会发生堵塞,比如说,大量的insert,update之类的请求同时到达MySQL,直接导致无数的行锁表锁,甚至最后请求会堆积过多,从而触发too many connections错误。通过使用消息队列,我们可以异步处理请求,从而缓解系统的压力。";
            string msg = "123";
            if (string.IsNullOrEmpty(ipPort)) ipPort = "127.0.0.1:39654";

            QClient producer = new QClient("productor" + Guid.NewGuid().ToString("N"), ipPort);

            producer.OnError += Producer_OnError;

            producer.OnDisconnected += Client_OnDisconnected;

            producer.ConnectAsync((s) =>
            {
                TaskHelper.LongRunning(() =>
                {
                    var old = 0;
                    var speed = 0;
                    while (producer.Connected)
                    {
                        speed = pNum - old;
                        old = pNum;
                        ConsoleHelper.WriteLine("生产者已成功发送:{0} 速度:{1}/s", pNum, speed);
                        Thread.Sleep(1000);
                    }
                });

                var list = new List<Tuple<string, byte[]>>();


                while (producer.Connected)
                {

                    producer.Publish(topic, msg);

                    Interlocked.Increment(ref pNum);
                }
            });


        }