public static TransStream DoResponse(IQueueItem item, MessageState state)
{
if (item == null)
{
return(null);
//throw new MessageException(MessageState.MessageError, "Invalid queue item to write response");
}
var ts = ((QueueItem)item).ToTransStream(state);
//((QueueItem)item).SetState(state);
QLogger.Debug("QueueController DoResponse IQueueAck: {0}", item.Print());
//return item.ToStream();
return(ts);
//if (item != null)
//{
// ((QueueItem)item).SetState(state);
// return item.GetItemStream();
//}
//else
//{
// Message response = Message.Ack(MessageState.UnExpectedError, new MessageException(MessageState.UnExpectedError, "WriteResponse error: there is no item stream to write reponse"));
// return response.ToStream();
//}
// QLogger.DebugFormat("Server WriteResponse State:{0}, MessageId: {1}", item.MessageState, item.MessageId);
}
public static QLogger SetLogger(bool enableLog, bool enableDebug)
{
if (_Logger == null)
{
_Logger = new QLogger(enableLog, enableDebug);
}
return(_Logger);
}
/// <summary>
/// Dequeue Message
/// </summary>
/// <returns></returns>
public virtual IQueueItem Dequeue(Priority priority)
{
Ptr ptr = Ptr.Empty;
try
{
//using (TransactionScope tran = new TransactionScope())
//{
switch (priority)
{
case Priority.Normal:
if (normalQ.TryDequeue(out ptr))
{
return(DequeueScop(ptr));
}
break;
case Priority.Medium:
if (mediumQ.TryDequeue(out ptr))
{
return(DequeueScop(ptr));
}
break;
case Priority.High:
if (highQ.TryDequeue(out ptr))
{
return(DequeueScop(ptr));
}
break;
}
return(null);
//if (ptr.IsEmpty)
//{
// return GetFirstItem();
//}
//else
//{
// return DequeueScop(ptr);
//}
//if (item == null)
//{
// item = Dequeue(priority);
//}
//}
}
catch (Exception ex)
{
QLogger.Exception("PriorityQueue Dequeue error ", ex);
}
return(null);
}
static void WriteReponse(Stream pipeServer, byte[] response)
{
int length = response.Length;
QLogger.Debug("Serevr WriteReponse:{0}", length);
pipeServer.Write(response, 0, length);
pipeServer.Flush();
}
public static TransStream DoResponse(IQueueItem item)
{
if (item == null)
{
return(null);
//throw new MessageException(MessageState.MessageError, "Invalid queue item to write response");
}
QLogger.Debug("QueueController DoResponse IQueueAck: {0}", item.Print());
return(item.ToTransStream());
}
/// <summary>
/// Dequeue Message
/// </summary>
/// <returns></returns>
public virtual IQueueItem Dequeue()
{
Ptr ptr = Ptr.Empty;
try
{
//using (TransactionScope tran = new TransactionScope())
//{
if (highQ.TryDequeue(out ptr))
{
return(DequeueScop(ptr));
}
else if (mediumQ.TryDequeue(out ptr))
{
return(DequeueScop(ptr));
}
else if (normalQ.TryDequeue(out ptr))
{
return(DequeueScop(ptr));
}
else
{
return(null);
}
//changed:syncCount:
//if (ptr == Guid.Empty)
// ptr = mediumQ.Dequeue();
//else if (ptr == Guid.Empty)
// ptr = normalQ.Dequeue();
//if (ptr.IsEmpty)
//{
// return GetFirstItem();
//}
//else
//{
// return DequeueScop(ptr);
//}
//if (item == null)
//{
// Thread.Sleep(300);
// return Dequeue();
//}
//}
}
catch (Exception ex)
{
QLogger.Exception("PriorityQueue Dequeue error ", ex);
}
return(null);
}
internal static void LogAction(MessageState state, string message)
{
if ((int)state < 100)
{
QLogger.Info("State:{0}, Message:{1}", state.ToString(), message);
}
else
{
QLogger.Error("State:{0}, Message:{1}", state.ToString(), message);
}
}
public PriorityFsQueue(IQProperties qp)
: base(qp.QueueName)
{
int numProcs = Environment.ProcessorCount;
int concurrencyLevel = numProcs * 2;
int initialCapacity = 101;
QueueList = new ConcurrentDictionary <Ptr, IQueueItem>(concurrencyLevel, initialCapacity);
CommitMode = (CommitMode)(int)qp.CommitMode;
CoverMode = qp.Mode;
if (CoverMode == CoverMode.FileStream)
{
DbLiteSettings settings = new DbLiteSettings()
{
Name = qp.QueueName,
CommitMode = (CommitMode)(int)qp.CommitMode,
DbPath = AgentManager.Settings.QueuesPath
};
//settings.SetFast();
QueueHost queueHost = qp.GetRoutHost();
m_fs = new FileMessage(queueHost);
//m_db = new PersistentBinary<IQueueItem>(settings);
////m_db = new PersistentDictionary(settings);
//m_db.BeginLoading += M_db_BeginLoading;
//m_db.LoadCompleted += M_db_LoadCompleted;
//m_db.ErrorOcurred += M_db_ErrorOcurred;
//m_db.ClearCompleted += M_db_ClearCompleted;
////m_db.ItemChanged += M_db_ItemChanged;
//m_db.ItemLoaded = (item) =>
//{
// this.ReEnqueue(item);
//};
if (qp.ReloadOnStart)
{
QLogger.InfoFormat("PriorityComplexQueue will load items to : {0}", qp.QueueName);
}
else
{
QLogger.InfoFormat("PriorityComplexQueue will clear all items from : {0}", qp.QueueName);
}
//m_db.ReloadOrClearPersist(qp.ReloadOnStart);
m_fs.ReloadItemsTo(0, (IQueueItem item) =>
{
this.ReEnqueue(item);
});
}
}
/// <summary>
/// Dequeue Message
/// </summary>
/// <returns></returns>
public virtual IQueueItem Dequeue(Ptr ptr)
{
try
{
return(DequeueScop(ptr));
}
catch (TransactionAbortedException tex)
{
QLogger.Exception("PriorityQueue Dequeue error ", tex);
}
catch (Exception ex)
{
QLogger.Exception("PriorityQueue Dequeue error ", ex);
}
return(null);
}
public static void WriteAck(Stream pipeStream, MessageState state, QueueCmd cmd, string label)
{
if (pipeStream == null)
{
throw new MessageException(MessageState.PipeError, "Invalid stream to write ack");
}
string lbl = label == null?state.ToString() : label;
QueueItem response = QueueItem.Ack(state, cmd, lbl, null);
using (NetStream stream = new NetStream())
{
response.EntityWrite(stream, null);
WriteReponse(pipeStream, stream.ToArray());
}
QLogger.Debug("Server Ack State:{0}, Label: {1}", state, label);
}
public static TransStream DoError(MessageState state, IQueueMessage message, bool responseAck, Exception ex)
{
try
{
string lbl = ex.Message;
if (responseAck)
{
return(new QueueAck(state, message, ex.Message).ToTransStream());
}
return(QueueItem.Ack(state, message.QCommand, ex).ToTransStream());
}
catch (Exception x)
{
QLogger.Error("QueueResponse WriteError Exception: " + x.Message);
//var ack = new Message(MessageState.StreamReadWriteError, new MessageException(MessageState.StreamReadWriteError, "Invalid stream to write ack"));
//return ack.GetEntityStream(false);
return(null);
}
}
public static void WriteError(Stream pipeStream, MessageState state, QueueCmd cmd, Exception ex)
{
if (pipeStream == null)
{
return;
}
try
{
string lbl = ex.Message;
QueueItem response = QueueItem.Ack(state, cmd, ex);
using (NetStream stream = new NetStream())
{
response.EntityWrite(stream, null);
WriteReponse(pipeStream, stream.ToArray());
}
}
catch (Exception x)
{
QLogger.Error("QueueResponse WriteError Exception: " + x.Message);
}
}
//public static void WriteResponse(Stream pipeStream, IQueueItem item, MessageState state)
//{
// if (pipeStream == null)
// {
// throw new MessageException(MessageState.PipeError, "Invalid stream to write response");
// }
// if (item != null)
// {
// ((QueueItem)item).SetState(state);
// WriteReponse(pipeStream, item.Serilaize());
// //using (NetStream stream = new NetStream())
// //{
// // //response.EntityWrite(stream, null);
// // WriteReponse(pipeStream, ((QueueItem)item).ItemBinary);
// //}
// }
// else
// {
// QueueItem response = QueueItem.Ack(MessageState.UnExpectedError,item.QCommand, new MessageException(MessageState.UnExpectedError, "WriteResponse error: there is no item stream to write reponse"));
// using (NetStream stream = new NetStream())
// {
// response.EntityWrite(stream, null);
// WriteReponse(pipeStream, stream.ToArray());
// }
// }
// QLogger.DebugFormat("Server WriteResponse State:{0}, Identifier: {1}", item.MessageState, item.Identifier);
//}
public static void WriteReport(Stream pipeStream, object item, QueueCmd cmd, MessageState state, string lbl)
{
if (pipeStream == null)
{
throw new MessageException(MessageState.PipeError, "Invalid stream to write report");
}
if (item != null)
{
var message = QueueItem.Ack(state, cmd, lbl, null);
message.SetBody(item);
WriteReponse(pipeStream, message.ToStream().ToArray());
}
else
{
QueueItem response = QueueItem.Ack(MessageState.UnExpectedError, cmd, new MessageException(MessageState.UnExpectedError, "WriteReport error: there is no item stream to write reponse"));
WriteReponse(pipeStream, response.ToStream().ToArray());
}
QLogger.Debug("Server WriteReport State:{0}, Command: {1}", state, cmd);
}
/// <summary>
/// Dequeue Message
/// </summary>
/// <returns></returns>
public virtual bool TryDequeue(out IQueueItem item)
{
Ptr ptr = Ptr.Empty;
try
{
//using (TransactionScope tran = new TransactionScope())
//{
if (highQ.TryDequeue(out ptr))
{
item = DequeueScop(ptr);
return(item != null);
}
else if (mediumQ.TryDequeue(out ptr))
{
item = DequeueScop(ptr);
return(item != null);
}
else if (normalQ.TryDequeue(out ptr))
{
item = DequeueScop(ptr);
return(item != null);
}
else
{
item = null;
return(false);
}
//}
}
catch (Exception ex)
{
QLogger.Exception("PriorityQueue Dequeue error ", ex);
}
item = null;
return(false);
}
public PersistQueue(IQProperties qp)
{
int numProcs = Environment.ProcessorCount;
int concurrencyLevel = numProcs * 2;
int initialCapacity = 101;
DbLiteSettings settings = new DbLiteSettings()
{
Name = qp.QueueName,
CommitMode = (CommitMode)(int)qp.CommitMode,
DbPath = AgentManager.Settings.QueuesPath
};
//settings.SetFast();
m_db = new PersistentBinary <IQueueItem>(settings);
//m_db = new PersistentDictionary(settings);
m_db.BeginLoading += M_db_BeginLoading;
m_db.LoadCompleted += M_db_LoadCompleted;
m_db.ErrorOcurred += M_db_ErrorOcurred;
m_db.ClearCompleted += M_db_ClearCompleted;
//m_db.ItemChanged += M_db_ItemChanged;
m_db.ItemLoaded = (item) =>
{
this.ReEnqueue(item);
};
if (qp.ReloadOnStart)
{
QLogger.InfoFormat("PersistQueue will load items to : {0}", qp.QueueName);
}
else
{
QLogger.InfoFormat("PersistQueue will clear all items from : {0}", qp.QueueName);
}
m_db.ReloadOrClearPersist(qp.ReloadOnStart);
}
private void M_db_BeginLoading(object sender, EventArgs e)
{
QLogger.InfoFormat("PersistQueue BeginLoading : {0}", m_db.Name);
}
protected override void OnErrorOcurred(string action, string message)
{
base.OnErrorOcurred(action, message);
QLogger.InfoFormat("PersistentQueue OnError : Name:{0}, action:{1}, message:{2}", this.Name, action, message);
}
protected override void OnInitilaized(EventArgs e)
{
base.OnInitilaized(e);
QLogger.InfoFormat("PersistentQueue OnInitilaized : Name:{0}", this.Name);
}
protected override void OnMessageReceived(QueueItemEventArgs e)
{
base.OnMessageReceived(e);
QLogger.Info("PriorityMemQueue OnMessageReceived : Host:{0}, Item:{1}", this.Name, e.Item.Print());
}
internal static void LogActionInfo(string state, string message)
{
QLogger.Info("State:{0}, Message:{1}", state, message);
}
private void M_db_LoadCompleted(object sender, Generic.GenericEventArgs <string, int> e)
{
QLogger.Info("PriorityComplexQueue LoadCompleted : {0}, Count:{1}", e.Args1, e.Args2);
}
//private void M_db_ItemChanged(object sender, Generic.GenericEventArgs<string, string, IQueueItem> e)
//{
// QLogger.InfoFormat("PriorityPersistQueue ItemChanged : action- {0}, key- {1}", e.Args1, e.Args2, e.Args3);
//}
private void M_db_ErrorOcurred(object sender, Generic.GenericEventArgs <string> e)
{
QLogger.Error("PriorityComplexQueue ErrorOcurred : {0}", e.Args);
}
private void M_db_BeginLoading(object sender, EventArgs e)
{
QLogger.Info("PriorityComplexQueue BeginLoading : {0}", m_db.Name);
}
private void M_db_ClearCompleted(object sender, EventArgs e)
{
QLogger.InfoFormat("PriorityComplexQueue ClearCompleted : {0}", m_db.Name);
}
protected override void OnMessageArrived(QueueItemEventArgs e)
{
base.OnMessageArrived(e);
QLogger.InfoFormat("PriorityPersistQueue OnMessageArrived : Host:{0}, Item:{1}", this.Name, e.Item.Print());
}
internal static void LogActionError(string state, string message)
{
QLogger.Error("State:{0}, Message:{1}", state, message);
}
//private void M_db_ItemChanged(object sender, Generic.GenericEventArgs<string, string, IQueueItem> e)
//{
// QLogger.InfoFormat("PersistQueue ItemChanged : action- {0}, key- {1}", e.Args1, e.Args2, e.Args3);
//}
private void M_db_ErrorOcurred(object sender, Generic.GenericEventArgs <string> e)
{
QLogger.ErrorFormat("PersistQueue ErrorOcurred : {0}", e.Args);
}
protected override void OnErrorOccured(QueueItemEventArgs e)
{
base.OnErrorOccured(e);
QLogger.Info("PriorityMemQueue OnError : Host:{0}, message:{1}", this.Name, e.Message);
}
protected virtual void OnTryPeek(Ptr ptr, IQueueItem item, bool result)
{
QLogger.DebugFormat("TryPeek {0} item:{1}", result, item.Print());
}
protected override void OnItemChanged(string action, string key, IPersistItem value)
{
base.OnItemChanged(action, key, value);
QLogger.InfoFormat("PersistentQueue OnItemChanged : Name:{0}", this.Name, action, key, key == null ? "" : value.Print());
}
