public void DequeueWorker() { while (KeepAlive) { IQueueItem item; try { foreach (var entry in MQ) { var q = entry.Value; if (q.TryDequeue(out item)) { EventQueue.Enqueue(item); } } } catch (Exception ex) { Netlog.Exception("Topic Dequeue Worker error ", ex); } Thread.Sleep(DequeueInterval); } Netlog.Warn("Topic Dequeue Worker stoped!"); }
protected virtual void OnSyncTask() { try { //this.LogAction(CacheAction.SyncTime, CacheActionState.Debug, "SyncTaskBox OnSyncTask... "); //0 indicates that the method is not in use. if (0 == Interlocked.Exchange(ref synchronized, 1)) { ISyncTask syncTask = null; if (m_SynBox.TryDequeue(out syncTask)) { //RenderTask(syncTask); syncTask.DoSync(); //this.LogAction(CacheAction.SyncTime, CacheActionState.Debug, "SyncTaskBox OnSyncTask RenderTask Start {0}", syncTask.ItemName); //Task task = Task.Factory.StartNew(() => syncTask.DoSynchronize()); } } } catch (Exception ex) { Netlog.Exception("SyncTaskBox OnSyncTask End error :", ex); } finally { //Release the lock Interlocked.Exchange(ref synchronized, 0); } }
private void InternalStart() { try { Netlog.Debug(serviceName + " start..."); m_ServerEnqueue = new ServerEnqueue(); m_ServerEnqueue.Start(false); m_ServerDequeue = new ServerDequeue(); m_ServerDequeue.Start(false); AgentManager.Start(); if (QueueSettings.EnableQueueManager) { m_ServerQueueManager = new ServerQueueManager(); m_ServerQueueManager.Start(false); } if (QueueSettings.EnableMailerQueue) { MailerStart(); } //svr.Start();//McLock.Lock.ValidateLock(), true); //host_serviceStart(); Netlog.Debug(serviceName + " started!"); } catch (Exception ex) { Netlog.Exception(serviceName + " InternalStart error ", ex, true, true); //File.AppendAllText(@"D:\Nistec\Services\MQueue.Agent\error.log", "error: " + ex.Message); } }
/// <summary> /// Dequeue Message /// </summary> /// <returns></returns> public virtual Ptr Dequeue() { Ptr ptr = Ptr.Empty; try { using (TransactionScope tran = new TransactionScope()) { if (highQ.TryDequeue(out ptr)) { return(ptr); } else if (mediumQ.TryDequeue(out ptr)) { return(ptr); } else if (normalQ.TryDequeue(out ptr)) { return(ptr); } else { return(ptr); } } } catch (Exception ex) { Netlog.Exception("PriorityQueue Dequeue error ", ex); } return(ptr); }
public void SendSubscriber(TopicSubscriber subscriber, QueueItem item) { try { var api = QueueApi.Get(subscriber.Protocol); //var message = item.ToMessage();// Message.Create(item.GetItemStream()); api.Send(item); } catch (Exception ex) { Netlog.Exception("Topic Sender Subscriber error ", ex); } }
public override void Stop() { KeepAlive = false; try { for (int i = 0; i < MaxThreads; i++) { thDequeueWorker[i].Join(); thSenderWorker[i].Join(); } } catch (Exception ex) { Netlog.Exception("Topic Stop error ", ex); } }
/// <summary> /// Dequeue Message /// </summary> /// <returns></returns> public virtual Ptr Dequeue(Priority priority) { Ptr ptr = Ptr.Empty; try { using (TransactionScope tran = new TransactionScope()) { switch (priority) { case Priority.Normal: if (normalQ.TryDequeue(out ptr)) { return(ptr); } break; case Priority.Medium: if (mediumQ.TryDequeue(out ptr)) { return(ptr); } break; case Priority.High: if (highQ.TryDequeue(out ptr)) { return(ptr); } break; } return(ptr); } } catch (Exception ex) { Netlog.Exception("PriorityQueue Dequeue error ", ex); } return(ptr); }
public void SenderWorker() { while (KeepAlive) { IQueueItem item; try { if (EventQueue.TryDequeue(out item)) { Send(item.Host, item as QueueItem); } } catch (Exception ex) { Netlog.Exception("Topic Sender Worker error ", ex); } Thread.Sleep(SenderInterval); } Netlog.Warn("Topic Sender Worker stoped!"); }
static void Main(string[] args) { try { if (args.Length > 0) { //Install service if (args[0].Trim().ToLower() == "/i") { System.Configuration.Install.ManagedInstallerClass.InstallHelper(new string[] { "/i", Assembly.GetExecutingAssembly().Location }); } //Uninstall service else if (args[0].Trim().ToLower() == "/u") { System.Configuration.Install.ManagedInstallerClass.InstallHelper(new string[] { "/u", Assembly.GetExecutingAssembly().Location }); } //run as console application else if (args[0].Trim().ToLower() == "/c") { ServiceManager SVC = new ServiceManager(); SVC.Start(); Console.WriteLine("Server Started as console"); Console.ReadKey(); } } else { Console.WriteLine("Server Started..."); System.ServiceProcess.ServiceBase[] ServicesToRun; ServicesToRun = new System.ServiceProcess.ServiceBase[] { new Service1() }; System.ServiceProcess.ServiceBase.Run(ServicesToRun); } } catch (Exception ex) { Netlog.Exception(Settings.ServiceName, ex, true, true); } }
/* * /// <summary> * /// Use the pipe classes in the System.IO.Pipes namespace to create the * /// named pipe. This solution is recommended. * /// </summary> * private void RunAsync() * { * NamedPipeServerStream pipeServerAsync = null; * bool connected = false; * //const string ResponseMessage = "Default response from server\0"; * Console.WriteLine("{0} Pipe server async start listen Thread<{1}>", PipeName, Thread.CurrentThread.ManagedThreadId); * * while (Listen) * { * * * try * { * // Prepare the security attributes (the pipeSecurity parameter in * // the constructor of NamedPipeServerStream) for the pipe. * PipeSecurity pipeSecurity = null; * pipeSecurity = CreateSystemIOPipeSecurity(); * * * // Create the named pipe. * pipeServerAsync = new NamedPipeServerStream( * PipeName, // The unique pipe name. * PipeDirection, // The pipe is duplex * NamedPipeServerStream.MaxAllowedServerInstances, * PipeTransmissionMode.Message, // Message-based communication * PipeOptions, // No additional parameters * InBufferSize, // Input buffer size * OutBufferSize, // Output buffer size * pipeSecurity, // Pipe security attributes * HandleInheritability.None // Not inheritable * ); * * //Netlog.InfoFormat("The named pipe ({0}) is created.", FullPipeName); * * // Wait for the client to connect. * //Netlog.Info("Waiting for the client's connection..."); * AsyncCallback myCallback = new AsyncCallback(WaitForConnectionAsyncCallback); * IAsyncResult asyncResult = pipeServerAsync.BeginWaitForConnection(myCallback, pipeServerAsync); * * while (!asyncResult.IsCompleted) * { * Thread.Sleep(100); * } * * connected = true; * //Netlog.Info("Client is connected."); * * //pipeServer.Flush(); * * // Flush the pipe to allow the client to read the pipe's contents * // before disconnecting. Then disconnect the client's connection. * pipeServerAsync.WaitForPipeDrain(); * pipeServerAsync.Disconnect(); * connected = false; * } * catch (Exception ex) * { * Netlog.Exception("The server throws the error: ", ex, ex.InnerException); * } * finally * { * if (pipeServerAsync != null) * { * if (connected && pipeServerAsync.IsConnected) * { * pipeServerAsync.Disconnect(); * } * pipeServerAsync.Close(); * pipeServerAsync = null; * } * } * } * Console.WriteLine("{0} Pipe server async stop listen Thread<{1}>", PipeName, Thread.CurrentThread.ManagedThreadId); * } */ private void WaitForConnectionAsyncCallback(IAsyncResult result) { Message message = null; try { NamedPipeServerStream pipeServerAsync = (NamedPipeServerStream)result.AsyncState; pipeServerAsync.EndWaitForConnection(result); //message = QueueItem.ReadServerRquest(pipeServerAsync, InBufferSize); //message=ReadRequest(pipeServerAsync); //NetStream res = ExecRequset(message); //WriteResponse(pipeServerAsync, res); Execute(pipeServerAsync); } catch (OperationCanceledException oex) { Netlog.Exception("Pipe server error, The pipe was canceled: ", oex); } catch (Exception ex) { Netlog.Exception("Pipe server error: ", ex, true); } finally { if (message != null) { ((IDisposable)message).Dispose(); message = null; } } }
//[PermissionSet(SecurityAction.Assert, Unrestricted = true)] private void InternalStart() { try { //System.Security.SecurityRules(RuleSet=System.Security.SecurityRuleSet.Level2) //using (FileStream fs = new FileStream(@"D:\Nistec\Services\Logs\qlog.log", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)) //{ // StreamWriter w = new StreamWriter(fs); // create a Char writer // w.BaseStream.Seek(0, SeekOrigin.End); // set the file pointer to the end // w.Write("log test" + "\r\n"); // w.Flush(); // update underlying file //} Netlog.Debug(serviceName + " start..."); //m_enableQueueController = AgentManager.Settings.EnableQueueController; //m_enableTopicController = AgentManager.Settings.EnableTopicController; AgentManager.Start();// m_enableQueueController, m_enableTopicController); if (AgentManager.Settings.EnablePipeProducer) { m_PipeServerProducer = new PipeServerChannel(QueueChannel.Producer, QueueSettings.DefaultQueueProducer); m_PipeServerProducer.Start(); //QLogger.Info("PipeServerChannel started..."); } if (AgentManager.Settings.EnablePipeConsumer) { m_PipeServerConsumer = new PipeServerChannel(QueueChannel.Consumer, QueueSettings.DefaultQueueConsumer); m_PipeServerConsumer.Start(); //QLogger.Info("PipeServerListener started..."); } //m_ServerDequeue = new PipeServerDequeue(); //m_ServerDequeue.Start(false); if (AgentManager.Settings.EnableTcpProducer) { m_TcpServerProducer = new TcpServerChannel(QueueChannel.Producer, QueueSettings.DefaultQueueProducer); m_TcpServerProducer.Start(); //QLogger.Info("TcpServerChannel started..."); } if (AgentManager.Settings.EnableTcpConsumer) { m_TcpServerConsumer = new TcpServerChannel(QueueChannel.Consumer, QueueSettings.DefaultQueueConsumer); m_TcpServerConsumer.Start(); //QLogger.Info("TcpServerListener started..."); } if (AgentManager.Settings.EnableHttpProducer) { m_HttpServerProducer = new HttpServerChannel(QueueChannel.Producer, QueueSettings.DefaultQueueProducer); m_HttpServerProducer.Start(); //QLogger.Info("HttpServerChannel started..."); } if (AgentManager.Settings.EnableHttpConsumer) { m_HttpServerConsumer = new HttpServerChannel(QueueChannel.Consumer, QueueSettings.DefaultQueueConsumer); m_HttpServerConsumer.Start(); //QLogger.Info("HttpServerListener started..."); } if (AgentManager.Settings.EnableQueueManager) { m_ServerQueueManager = new PipeServerChannel(QueueChannel.Manager, QueueSettings.DefaultQueueManager); m_ServerQueueManager.IsAsync = false; m_ServerQueueManager.Start();// (false); //QLogger.Info("ServerQueueManager started..."); } //if (AgentManager.Settings.EnableFolderListener) //{ // m_FolderServer = new FolderServerListener(); // m_FolderServer.Start(); //} //if (AgentManager.Settings.EnableDbListener) //{ // m_DbServer = new DbServerListener(); // m_DbServer.Start(); //} //svr.Start();//McLock.Lock.ValidateLock(), true); //host_serviceStart(); Netlog.Debug(serviceName + " started!"); } catch (Exception ex) { Netlog.Exception(serviceName + " InternalStart error ", ex, true, true); //File.AppendAllText(@"D:\Nistec\Services\MQueue.Agent\error.log", "error: " + ex.Message); } }
private void Exec(bool isAsync) { NamedPipeServerStream pipeServer = null; Message message = null; bool connected = false; try { // Prepare the security attributes (the pipeSecurity parameter in // the constructor of NamedPipeServerStream) for the pipe. PipeSecurity pipeSecurity = null; pipeSecurity = CreateSystemIOPipeSecurity(); // Create the named pipe. pipeServer = new NamedPipeServerStream( PipeName, // The unique pipe name. PipeDirection, // The pipe is duplex NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Message, // Message-based communication PipeOptions, // No additional parameters InBufferSize, // Input buffer size OutBufferSize, // Output buffer size pipeSecurity, // Pipe security attributes HandleInheritability.None // Not inheritable ); if (isAsync) { AsyncCallback myCallback = new AsyncCallback(WaitForConnectionAsyncCallback); IAsyncResult asyncResult = pipeServer.BeginWaitForConnection(myCallback, pipeServer); while (!asyncResult.IsCompleted) { Thread.Sleep(100); } connected = true; } else { //Netlog.InfoFormat("The named pipe ({0}) is created.", FullPipeName); // Wait for the client to connect. //Netlog.Info("Waiting for the client's connection..."); pipeServer.WaitForConnection(); connected = true; //Netlog.Info("Client is connected."); //message = QueueItem.ReadServerRquest(pipeServer, InBufferSize); //message = ReadRequest(pipeServer); //NetStream res = ExecRequset(message); //WriteResponse(pipeServer, res); Execute(pipeServer); //pipeServer.Flush(); } // Flush the pipe to allow the client to read the pipe's contents // before disconnecting. Then disconnect the client's connection. pipeServer.WaitForPipeDrain(); pipeServer.Disconnect(); connected = false; } catch (Exception ex) { Netlog.Exception("The server throws the error: ", ex, true, true); } finally { if (pipeServer != null) { if (connected && pipeServer.IsConnected) { pipeServer.Disconnect(); } pipeServer.Close(); pipeServer = null; } if (message != null) { ((IDisposable)message).Dispose(); message = null; } } }
/* * internal void Execute(QItemStream request, Stream stream) * { * try * { * switch (request.Command) * { * case QueueCmd.Enqueue: * MessageAckServer.WriteAck(stream, ExecSet(request), null); * break; * case QueueCmd.Dequeue: * case QueueCmd.DequeuePriority: * case QueueCmd.DequeueItem: * case QueueCmd.Peek: * case QueueCmd.PeekPriority: * case QueueCmd.PeekItem: * MessageAckServer.WriteResponse(stream, ExecGet(request), MessageState.Receiving); * break; * case QueueCmd.Commit: * * break; * case QueueCmd.Abort: * * break; * * //operation * case QueueCmd.AddQueue: * MQueue mq = null; * MessageAckServer.WriteAck(stream, AddQueue(QProperties.Get(request.GetHeader()), out mq), null); * break; * case QueueCmd.RemoveQueue: * MessageAckServer.WriteAck(stream, RemoveQueue(request.Host.HostName), null); * break; * case QueueCmd.HoldEnqueue: * throw new Exception("Operation not supported"); * case QueueCmd.NoneHoldEnqueue: * throw new Exception("Operation not supported"); * case QueueCmd.HoldDequeue: * throw new Exception("Operation not supported"); * case QueueCmd.NoneHoldDequeue: * throw new Exception("Operation not supported"); * case QueueCmd.EnableQueue: * throw new Exception("Operation not supported"); * case QueueCmd.DisableQueue: * throw new Exception("Operation not supported"); * //reports * case QueueCmd.Exists: * MessageAckServer.WriteAck(stream, Exists(request.Host.HostName), null); * break; * case QueueCmd.QueueProperty: * throw new Exception("Operation not supported"); * case QueueCmd.ReportQueueList: * GetQueueList(); * break; * case QueueCmd.ReportQueueItems: * throw new Exception("Operation not supported"); * case QueueCmd.ReportQueueStatistic: * throw new Exception("Operation not supported"); * case QueueCmd.PerformanceCounter: * throw new Exception("Operation not supported"); * case QueueCmd.QueueCount: * MessageAckServer.WriteReport(stream, QueueCount(request.Host.HostName), QueueCmd.QueueCount, MessageState.Ok, null); * break; * } * } * catch (MessageException mex) * { * MessageAckServer.WriteError(stream, mex.MessageState, mex); * Netlog.Exception("ExecGet MessageException: ", mex, true); * } * catch (ArgumentException ase) * { * MessageAckServer.WriteError(stream, MessageState.ArgumentsError, ase); * Netlog.Exception("ExecGet ArgumentException: ", ase, true, true); * } * catch (SerializationException se) * { * MessageAckServer.WriteError(stream, MessageState.SerializeError, se); * Netlog.Exception("ExecGet SerializationException: ", se, true); * } * catch (Exception ex) * { * MessageAckServer.WriteError(stream, MessageState.UnExpectedError, ex); * Netlog.Exception("ExecGet Exception: ", ex, true, true); * } * * } */ internal NetStream ExecRequset(QItemStream request) { try { switch (request.Command) { case QueueCmd.Enqueue: return(MessageAckServer.DoAck(ExecSet(request), null)); case QueueCmd.Dequeue: case QueueCmd.DequeuePriority: case QueueCmd.DequeueItem: case QueueCmd.Peek: case QueueCmd.PeekPriority: case QueueCmd.PeekItem: return(MessageAckServer.DoResponse(ExecGet(request), MessageState.Receiving)); case QueueCmd.Commit: break; case QueueCmd.Abort: break; //operation case QueueCmd.AddQueue: MQueue mq = null; return(MessageAckServer.DoAck(AddQueue(new QProperties(request.GetBodyStream()), out mq), null)); case QueueCmd.RemoveQueue: return(MessageAckServer.DoAck(RemoveQueue(request.Destination), null)); case QueueCmd.HoldEnqueue: throw new Exception("Operation not supported"); case QueueCmd.NoneHoldEnqueue: throw new Exception("Operation not supported"); case QueueCmd.HoldDequeue: throw new Exception("Operation not supported"); case QueueCmd.NoneHoldDequeue: throw new Exception("Operation not supported"); case QueueCmd.EnableQueue: throw new Exception("Operation not supported"); case QueueCmd.DisableQueue: throw new Exception("Operation not supported"); //reports case QueueCmd.Exists: return(MessageAckServer.DoAck(Exists(request.Destination), null)); case QueueCmd.QueueProperty: throw new Exception("Operation not supported"); case QueueCmd.ReportQueueList: GetQueueList(); break; case QueueCmd.ReportQueueItems: throw new Exception("Operation not supported"); case QueueCmd.ReportQueueStatistic: throw new Exception("Operation not supported"); case QueueCmd.PerformanceCounter: throw new Exception("Operation not supported"); case QueueCmd.QueueCount: return(MessageAckServer.DoReport(QueueCount(request.Destination), QueueCmd.QueueCount, MessageState.Ok, null)); } } catch (MessageException mex) { Netlog.Exception("ExecGet MessageException: ", mex, true); return(MessageAckServer.DoError(mex.MessageState, mex)); } catch (ArgumentException ase) { Netlog.Exception("ExecGet ArgumentException: ", ase, true, true); return(MessageAckServer.DoError(MessageState.ArgumentsError, ase)); } catch (SerializationException se) { Netlog.Exception("ExecGet SerializationException: ", se, true); return(MessageAckServer.DoError(MessageState.SerializeError, se)); } catch (Exception ex) { Netlog.Exception("ExecGet Exception: ", ex, true, true); return(MessageAckServer.DoError(MessageState.UnExpectedError, ex)); } return(null); }
//[PermissionSet(SecurityAction.Assert, Unrestricted = true)] private void InternalStart() { try { //System.Security.SecurityRules(RuleSet=System.Security.SecurityRuleSet.Level2) //using (FileStream fs = new FileStream(@"D:\Nistec\Services\Logs\qlog.log", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)) //{ // StreamWriter w = new StreamWriter(fs); // create a Char writer // w.BaseStream.Seek(0, SeekOrigin.End); // set the file pointer to the end // w.Write("log test" + "\r\n"); // w.Flush(); // update underlying file //} Netlog.Debug(serviceName + " start..."); AgentManager.Start(); //m_ServerEnqueue = new PipeServerEnqueue(); //m_ServerEnqueue.Start(false); //m_ServerDequeue = new PipeServerDequeue(); //m_ServerDequeue.Start(false); //if (AgentManager.Settings.EnableQueueManager) //{ // m_ServerQueueManager = new PipeServerManager(); // m_ServerQueueManager.Start(false); //} //if (AgentManager.Settings.EnableTcpListener) //{ m_TcpServer = new TcpServerListener(); if (m_TcpServer.Adapters.Count > 0) { //m_TcpServer.Start(); } m_TcpServer.Start(); //} //if (AgentManager.Settings.EnableFolderListener) //{ // m_FolderServer = new FolderServerListener(); // m_FolderServer.Start(); //} //if (AgentManager.Settings.EnableDbListener) //{ // m_DbServer = new DbServerListener(); // m_DbServer.Start(); //} //svr.Start();//McLock.Lock.ValidateLock(), true); //host_serviceStart(); Netlog.Debug(serviceName + " started!"); } catch (Exception ex) { Netlog.Exception(serviceName + " InternalStart error ", ex, true, true); //File.AppendAllText(@"D:\Nistec\Services\MQueue.Agent\error.log", "error: " + ex.Message); } }