public AcknowledgeStatus EnqueueMessage(string serItem) { try { QueueItem item = QueueItem.Deserialize(serItem); if (item == null) { throw new MessageException(AcknowledgeStatus.BadRequest, "QueueItem.Deserialize failed"); } EnqueueMessage(item); return(AcknowledgeStatus.Received); } catch (MessageException mex) { Netlog.ErrorFormat("RemoteService MailerService EnqueueMessage error: {0}", mex.Message); return(mex.AcknowledgeStatus); } catch (Exception ex) { Netlog.ErrorFormat("RemoteService MailerService Error: {0}", ex.Message); Netlog.ErrorFormat("RemoteService MailerService ErrorStackTrace: {0}", ex.StackTrace); return(AcknowledgeStatus.UnExpectedError); } }
/// <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 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!"); }
private MessageState SendMessageInternal(QueueMessage msg) { try { if (msg == null) { throw new MessageException(MessageState.ArgumentsError, "QueueMessage null"); } msg.Validate(); switch (msg.MessageType)//.DistributionMode) { case MessageTypes.DirectToQueue: SendDirectToQueue(msg); break; case MessageTypes.BatchToMailer: SendBatchToQueue(msg); break; case MessageTypes.SplitToQueue: SendSplitToQueue(msg); break; } return(MessageState.Received); } catch (MessageException mex) { Netlog.ErrorFormat("QueueProxy SendMessageInternal MessageException : {0}", mex.Message); return(mex.MessageState); } catch (Exception ex) { Netlog.ErrorFormat("QueueProxy SendMessageInternal Error: {0}", ex.Message); return(MessageState.UnExpectedError); } }
public void DequeueItem() { QueueClient client = new QueueClient(queuenmae); var message = client.Receive(); Netlog.DebugFormat("Client Receive state:{0}", message.Print()); }
public void Start() { if (keepAlive) { return; } //Netcell.Log.Debug("Start Mailer_Manager"); foreach (KeyValuePair <string, MailHost> channel in m_channels.Items) { channel.Value.ValidateDirectory(MailConfig.MailQueuePath); Mail_Distrebuter mailer = new Mail_Distrebuter(channel.Value); m_disterbuters[channel.Key] = mailer; } foreach (string key in m_disterbuters.Keys) { m_disterbuters[key].Start(); Thread.Sleep(100); } keepAlive = true; threadManager = new Thread(new ThreadStart(MailerProcess)); threadManager.Start(); Netlog.Debug("Mailer_Manager in process"); }
public void Stop() { //Netcell.Log.Debug("Stop Mailer_Manager"); try { keepAlive = false; if (m_disterbuters != null) { foreach (string key in m_disterbuters.Keys) { m_disterbuters[key].Stop(); Thread.Sleep(10); } } if (threadManager != null) { threadManager.Abort();; threadManager = null; } } catch (Exception ex) { Netlog.ErrorFormat("Stop Mailer_Manager:{0}", ex.Message); } }
/// <summary> /// Load Settings from config. /// </summary> /// <param name="isServer"></param> /// <returns></returns> public static TcpSettings[] LoadSettings(bool isServer) { List <TcpSettings> list = new List <TcpSettings>(); try { System.Configuration.Configuration config = NetConfig.GetConfiguration(); XmlDocument doc = new XmlDocument(); doc.Load(config.FilePath); Netlog.Debug("LoadSettings : " + config.FilePath); string xpath = isServer ? "//TcpServerSettings" : "//TcpClientSettings"; XmlNode root = doc.SelectSingleNode(xpath); foreach (XmlNode n in root.ChildNodes) { if (n.NodeType == XmlNodeType.Comment) { continue; } TcpSettings ps = new TcpSettings(n, isServer); list.Add(ps); } return(list.ToArray()); } catch (Exception ex) { throw ex; } }
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); } }
public void QueueCount() { QueueClient client = new QueueClient(queuenmae); var ack = client.Report <int>(QueueCmdReport.QueueCount); Netlog.DebugFormat("Client QueueCount :{0}", ack); }
/* * ServiceHost host_service; * private void host_serviceStart() * { * System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo(1033); * System.Threading.Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo(1033); * * host_service = new ServiceHost(typeof(MobileDeviceService)); * host_service.Open(); * * RemotingConfiguration.Configure(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, false); * * Console.WriteLine("MobileService is available."); * * } */ public void Stop() { Netlog.Debug(serviceName + " stop..."); if (m_ServerDequeue != null) { m_ServerDequeue.Stop(); } if (m_ServerEnqueue != null) { m_ServerEnqueue.Stop(); } if (m_ServerQueueManager != null) { m_ServerQueueManager.Stop(); } MailerStop(); //if (svr != null) //{ // svr.Stop(); //} //if (host_service != null) //{ // host_service.Close(); //} Netlog.Debug(serviceName + " stoped."); }
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>Deletes a queue on a Message Queuing server.</summary> /// <param name="queueName">The location of the queue to be deleted. </param> public bool RemoveQueue(string queueName) { if (queueName == null) { throw new ArgumentNullException("queueName"); } if (queueName.Length == 0) { throw new ArgumentException("InvalidParameter", "queueName"); } //RemoveDbQueue(queueName); MQueue queue; if (MQ.TryRemove(queueName, out queue)) { Netlog.InfoFormat("RemoveQueue : {0}", queueName); return(true); } else { Netlog.InfoFormat("RemoveQueue not removed : {0}", queueName); return(false); } }
public MessageState AddQueue(QProperties prop, out MQueue mq) { if (MQ.ContainsKey(prop.QueueName)) { if (prop.ReloadOnStart) { MQueue q = new MQueue(prop); MQ[prop.QueueName] = q; mq = q; } else { mq = MQ[prop.QueueName]; } return(MessageState.AllreadyExists); } //if (prop.IsDbQueue) //{ // AddDbQueue(prop.QueueName, prop.IsTrans); //} MQueue queue = new MQueue(prop); MQ[prop.QueueName] = queue; mq = queue; Netlog.InfoFormat("AddQueue : {0}", prop.Print()); return(MessageState.Ok); }
public void Stop() { Netlog.Debug(serviceName + " stop..."); if (m_ServerDequeue != null) { m_ServerDequeue.Stop(); } if (m_ServerEnqueue != null) { m_ServerEnqueue.Stop(); } if (m_ServerQueueManager != null) { m_ServerQueueManager.Stop(); } if (m_TcpServer != null) { m_TcpServer.Stop(true); } if (m_FolderServer != null) { m_FolderServer.Stop(true); } if (m_DbServer != null) { m_DbServer.Stop(true); } Netlog.Debug(serviceName + " stoped."); }
protected override void OnMessageReceived(QueueItemEventArgs e) { base.OnMessageReceived(e); IQueueItem item = e.Item; if (item == null) { return; } if (e.State == ItemState.Dequeue) { base.CommitTrans(item.ItemId, item.HasAttach); } Console.WriteLine("Queue{0} Items count: {1}", QueueName, base.Count); if (item != null) { Console.WriteLine("Queue{0} MessageReceived: {1}, Duration:{2}", QueueName, item.ItemId, item.Duration()); } else { Console.WriteLine("Queue{0} Receive timeout", QueueName); } Netlog.InfoFormat("OnMessageReceived:{0} Received:{1}", e.Item.MessageId, e.Item.SentTime); if (base.Count <= 0) { TimeSpan ts = DateTime.Now.Subtract(start); Console.WriteLine("Time took:{0}", ts.TotalSeconds); } }
public void AddItem(int index) { QueueClient client = new QueueClient(queuenmae); var message = new Message("QClient", queuenmae, new EntityDemo(index)); var ack = client.Send(message); Netlog.DebugFormat("Client Send state:{0}", ack.Print()); }
private void MailerProcess() { while (keepAlive) { Thread.Sleep(intervalManager); } Netlog.WarnFormat("Mailer_Manager not keep Alive"); }
private void InternalStart() { while (KeepAlive) { DoSync(); Thread.Sleep(1000); } Netlog.Warn("Initialized SyncTaskBox Not keep alive"); }
public void Stop() { _IsListen = false; if (initilaized) { _configFileWatcher.FileChanged -= new FileSystemEventHandler(_ConfigFileWatcher_FileChanged); } initilaized = false; Netlog.Debug("ConfigFileWatcher stoped..."); }
private void ReEnqueueFiles() { if (reEnqueueItems) { return; } try { Console.WriteLine("Start ReEnqueueQueueItems"); reEnqueueItems = true; string path = GetRelayPath(); if (Directory.Exists(path)) { string[] messages = Directory.GetFiles(path, "*.mcq"); if (messages == null || messages.Length == 0) { return; } Console.WriteLine("{0} items found to ReEnqueue", messages.Length); Netlog.InfoFormat("ReEnqueueFiles: {0} ", messages.Length); foreach (string message in messages) { //while (this.Count > 1000) //{ // Thread.Sleep(1000); //} QueueItem item = QueueItem.ReadFile(message); if (item != null) { Enqueue(item as IQueueItem); } SysUtil.DeleteFile(message); Thread.Sleep(100); } Netlog.Info("ReEnqueueFiles finished. "); } } catch (Exception ex) { string s = ex.Message; } finally { reEnqueueItems = false; } }
//public void Add(SyncTask task, DataSyncEntity entity, IDataCache owner) //{ // if (task == null || entity == null || owner == null) // { // this.LogAction(CacheAction.SyncTime, CacheActionState.Failed, "SyncTaskBox can not add task null!"); // return; // } // Add(new SyncBoxTask() // { // Entity = entity, // //ItemName = task.ItemName, // Owner = owner // //TaskItem = task.Item // }); //} public void Add(ISyncTask item) { if (item == null) { Netlog.Warn("SyncTaskBox can not add task null!"); return; } m_SynBox.Enqueue(item); Netlog.DebugFormat("SyncTaskBox Added SyncBoxTask {0}", item.ItemName); }
public TransSyncBox(bool autoStart, bool isRemote) { m_SynBox = new ConcurrentQueue <ISyncTask>(); IsRemote = isRemote; this.Initialized = true; Netlog.Debug("Initialized SynTaskBox"); if (autoStart) { Start(); } }
public void Stop() { Netlog.Debug(serviceName + " stop..."); try { //if (m_ServerDequeue != null) // m_ServerDequeue.Stop(); if (m_PipeServerProducer != null) { m_PipeServerProducer.Stop(); } if (m_TcpServerProducer != null) { m_TcpServerProducer.Stop(); } if (m_HttpServerProducer != null) { m_HttpServerProducer.Stop(); } if (m_PipeServerConsumer != null) { m_PipeServerConsumer.Stop(); } if (m_TcpServerConsumer != null) { m_TcpServerConsumer.Stop(); } if (m_HttpServerConsumer != null) { m_HttpServerConsumer.Stop(); } if (m_ServerQueueManager != null) { m_ServerQueueManager.Stop(); } //if (m_FolderServer != null) // m_FolderServer.Stop(true); //if (m_DbServer != null) // m_DbServer.Stop(true); Netlog.Debug(serviceName + " stoped."); } catch (Exception ex) { Netlog.Debug(serviceName + " stop error: " + ex.Message); } }
static void Main(string[] args) { Netlog.Info("test log"); string qtype = "remote"; string queueName = "NC_DEMO"; /* * RemotingTable rt = new RemotingTable(); * rt.AddTrans("123",new TimeSpan(0,0,30)); * //rt.Push("123", "hello"); * * TransItem ti= rt.Pop("123"); * Console.WriteLine(ti.ItemState.ToString()); * //rt.Push("123", "hello"); * Console.WriteLine("trans push"); */ //if (args.Length == 0) //{ // throw new ArgumentNullException("Invalid argument"); //} //McQueueProperties prop = new McQueueProperties(queueName); //prop.CoverMode = CoverMode.FileSystem; //prop.Server = 0; //prop.IsTrans = false; //McQueue queue = McQueue.Create(prop); if (qtype == "queue") { McQueue q = new McQueue("demo"); } else { RemoteQueueInserter qi = new RemoteQueueInserter(args); while (true) { DateTime start = DateTime.Now; qi.Start(1000); TimeSpan ts = DateTime.Now.Subtract(start); Console.WriteLine("Total secondes={0}", ts.TotalSeconds); Thread.Sleep(2000); } } Console.ReadLine(); }
void QueueStop() { //Log.Debug("MailerManager stop..."); if (manager != null) { manager.Stop(); } if (host_queue != null) { host_queue.Close(); } Netlog.Debug("QueueService stoped"); }
void MailerStop() { //Log.Debug("MailerManager stop..."); if (manager != null) { manager.Stop(); } if (host_mailer != null) { host_mailer.Close(); } Netlog.Debug("MailerService stoped"); }
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 static void DeleteFile(string filename) { if (File.Exists(filename)) { try { File.Delete(filename); } catch (Exception ex) { Netlog.ErrorFormat("Error DeleteFile: {0}, {1} ", filename, ex.Message); } } }
public static void MoveFile(string source, string dest) { try { if (File.Exists(dest)) { File.Delete(dest); } File.Move(source, dest); } catch (Exception ex) { Netlog.ErrorFormat("Error MoveFile: {0}, {1} ", dest, ex.Message); } }