public void Init()
        {
            if (File.Exists(@"AzureDocument0.pdf"))
            {
                File.Delete(@"AzureDocument0.pdf");
            }
            var queueName = "testqueue";

            _statusQueueName = "testStatusQueue";
            _server          = new QueueServer(Directory.GetCurrentDirectory(), queueName, _statusQueueName);
            _server.Start();
        }
示例#2
0
文件: Form1.cs 项目: yyan/winform
        private void btnQueneServer_Click(object sender, EventArgs e)
        {
            QueueServer <PreDataInfo> queueServer = new QueueServer <PreDataInfo>();

            queueServer.IsBackground = true;
            queueServer.ProcessItem += new Action <PreDataInfo>(queueServer_ProcessItem);

            //循环入队
            for (int i = 0; i < 100; i++)
            {
                queueServer.EnqueueItem(new PreDataInfo(i.ToString(), DateTimeHelper.GetServerDateTime2().ToString()));
                Thread.Sleep(10);
            }
        }
示例#3
0
 public void OnPause()
 {
     try
     {
         Core.Log.InfoBasic("Pausing messaging service");
         _cTokenSource.Cancel();
         QueueServer.StopListeners();
         Core.Log.InfoBasic("Messaging service is paused");
     }
     catch (Exception ex)
     {
         Core.Log.Write(ex);
         //throw;
     }
 }
示例#4
0
 public void OnContinue()
 {
     try
     {
         Core.Log.InfoBasic("Continuing messaging service");
         _cTokenSource = new CancellationTokenSource();
         QueueServer.StartListeners();
         Core.Log.InfoBasic("Messaging service is running");
     }
     catch (Exception ex)
     {
         Core.Log.Write(ex);
         //throw;
     }
 }
        public void Init()
        {
            NamespaceManager namespaceManager = NamespaceManager.Create();
            var queueName = "testqueue";

            if (namespaceManager.QueueExists(queueName))
            {
                namespaceManager.DeleteQueue(queueName);
            }

            _server = new QueueServer(queueName);
            namespaceManager.CreateQueue(new QueueDescription(queueName)
            {
                EnablePartitioning = false
            });
            _client = QueueClient.Create(queueName, ReceiveMode.ReceiveAndDelete);
        }
示例#6
0
 public void OnStop()
 {
     try
     {
         _cTokenSource.Cancel();
         OnFinalizing();
         Core.Log.InfoBasic("Stopping messaging service");
         QueueServer.StopListeners();
         QueueServer.Dispose();
         Processor.Dispose();
         OnDispose();
         Core.Log.InfoBasic("Messaging service stopped.");
     }
     catch (Exception ex)
     {
         Core.Log.Write(ex);
         //throw;
     }
 }
示例#7
0
 public void OnStart(string[] args)
 {
     try
     {
         Core.Log.InfoBasic("Starting messaging service");
         _cTokenSource = new CancellationTokenSource();
         OnInit(args);
         Status      = new MessagingServiceStatus(this);
         QueueServer = GetQueueServer();
         if (QueueServer is null)
         {
             throw new Exception("The queue server is null, please check the configuration file and ensure the Types assemblies are on the assembly folder.");
         }
         Processor = GetMessageProcessorAsync(QueueServer);
         if (Processor is null)
         {
             throw new Exception("The message processor is null, please check your GetMessageProcessor method implementation.");
         }
         if (QueueServer.ResponseServer)
         {
             QueueServer.ResponseReceived += ResponseReceivedHandler;
         }
         else
         {
             QueueServer.RequestReceived    += RequestReceivedHandler;
             QueueServer.BeforeSendResponse += BeforeSendResponseHandler;
             QueueServer.ResponseSent       += ResponseSentHandler;
         }
         Processor.Init();
         QueueServer.StartListeners();
         Core.Log.InfoBasic("Messaging service started.");
     }
     catch (Exception ex)
     {
         Core.Log.Write(ex);
         throw;
     }
 }
示例#8
0
 public CancelationQueueReceiver(CancelSynchronizedCollection cancelSynchronizedCollection)
 {
     _cancelSynchronizedCollection = cancelSynchronizedCollection;
     _queueServer           = new QueueServer(CancelQueueName);
     _queueServer.Received += OnRecived;
 }
        /// <inheritdoc />
        /// <summary>
        /// On Service Start method
        /// </summary>
        /// <param name="args">Start arguments</param>
        public void OnStart(string[] args)
        {
            try
            {
                Core.Log.InfoBasic("Starting messaging service");
                _cTokenSource = new CancellationTokenSource();
                OnInit(args);
                Status      = new MessagingServiceStatus(this);
                QueueServer = GetQueueServer();
                if (QueueServer == null)
                {
                    throw new Exception("The queue server is null, please check the configuration file and ensure the Types assemblies are on the assembly folder.");
                }
                Processor = GetMessageProcessorAsync(QueueServer);
                if (Processor == null)
                {
                    throw new Exception("The message processor is null, please check your GetMessageProcessor method implementation.");
                }
                if (QueueServer.ResponseServer)
                {
                    QueueServer.ResponseReceived += async(s, e) =>
                    {
                        if (MessageReceived != null)
                        {
                            await MessageReceived.InvokeAsync(this, new MessageEventArgs(e.Message)).ConfigureAwait(false);
                        }
                        if (e.Message?.Body == null)
                        {
                            return;
                        }

                        ReceivedMessagesCache.TryAdd(e.Message.Body, e.Message);
                        Status.IncrementCurrentMessagesBeingProcessed();
                        var sw = Stopwatch.StartNew();
                        try
                        {
                            await Processor.ProcessAsync(e.Message.Body, _cTokenSource.Token).ConfigureAwait(false);
                        }
                        catch (Exception ex)
                        {
                            Core.Log.Write(ex);
                            Status.IncrementTotalExceptions();
                        }
                        sw.Stop();
                        Status.ReportProcessingTime(sw.Elapsed.TotalMilliseconds);
                        Status.DecrementCurrentMessagesBeingProcessed();
                        Status.IncrementTotalMessagesProccesed();
                        ReceivedMessagesCache.TryRemove(e.Message.Body, out object _);
                    };
                }
                else
                {
                    QueueServer.RequestReceived += async(s, e) =>
                    {
                        if (MessageReceived != null)
                        {
                            await MessageReceived.InvokeAsync(this, new MessageEventArgs(e.Request)).ConfigureAwait(false);
                        }
                        if (e.Request?.Body == null)
                        {
                            return;
                        }

                        ReceivedMessagesCache.TryAdd(e.Request.Body, e.Request);
                        object result = null;
                        Status.IncrementCurrentMessagesBeingProcessed();
                        var sw = Stopwatch.StartNew();
                        try
                        {
                            result = await Processor.ProcessAsync(e.Request.Body, e.ProcessResponseTimeoutCancellationToken).ConfigureAwait(false);
                        }
                        catch (Exception ex)
                        {
                            Core.Log.Write(ex);
                            Status.IncrementTotalExceptions();
                        }
                        sw.Stop();
                        Status.ReportProcessingTime(sw.Elapsed.TotalMilliseconds);
                        Status.DecrementCurrentMessagesBeingProcessed();
                        Status.IncrementTotalMessagesProccesed();
                        e.Response.Body = result;
                        ReceivedMessagesCache.TryRemove(e.Request.Body, out object _);
                    };
                    QueueServer.BeforeSendResponse += async(s, e) =>
                    {
                        if (BeforeSendMessage != null)
                        {
                            await BeforeSendMessage.InvokeAsync(this, new MessageEventArgs(e.Message)).ConfigureAwait(false);
                        }
                    };
                    QueueServer.ResponseSent += async(s, e) =>
                    {
                        if (MessageSent != null)
                        {
                            await MessageSent.InvokeAsync(this, new MessageEventArgs(e.Message)).ConfigureAwait(false);
                        }
                    };
                }

                Processor.Init();
                QueueServer.StartListeners();
                Core.Log.InfoBasic("Messaging service started.");
            }
            catch (Exception ex)
            {
                Core.Log.Write(ex);
                throw;
            }
        }