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);
}
}
