public bool PushMessage(TaskQueue.Providers.TaskMessage msg)
{
ChannelAnteroom ch = MessageChannels.GetAnteroomByMessage(msg.MType);
if (ch == null)
{
logger.Warning("push: unknown message type: {0}", msg.MType);
return false;
}
//ch.ChannelStatsIn.inc();
//return true;
msg.AddedTime = DateTime.UtcNow;
bool status = ch.Push(msg);
if (status)
{
ch.ChannelStatsIn.inc();
}
else
{
logger.Warning("push: can't enqueue message mtype: {0}, channel: {1}", msg.MType, ch.ChannelName);
}
// TODO: replace with suspend interface
//var x = from t in Tasks
// where t.ChannelName == ch.ChannelName
// select t;
//foreach (QueueTask t in x)
//{
// t.Suspended = false;
//}
// ~
return status;
}
public TaskQueue.Providers.TaskMessage Next()
{
lock (anteroom)
{
// the internal tuple is empty
if (anteroom.Count == 0)
{
TaskQueue.Providers.TaskMessage result = Queue.GetItem();
if (result != null)
{
long qlen = Queue.GetQueueLength();
if (qlen >= 100)
{
TaskQueue.Providers.TaskMessage[] items = null;
try
{
items = Queue.GetItemTuple();
}
catch (Exception e)
{
logger.Exception(e, "Message Take", "anteroom take error");
return(null);
}
if (items != null && items.Length > 0)
{
anteroom = new Queue <TaskMessage>(items);
//anteroom = new ConcurrentQueue<TaskMessage>(items);
return(result);
}
// the channel queue is empty
InternalEmptyFlag = true;
return(null);
}
InternalEmptyFlag = result == null;
return(result);
}
else
{
InternalEmptyFlag = true;
return(null);
}
}
else
{
TaskQueue.Providers.TaskMessage result = anteroom.Dequeue();
//TaskQueue.Providers.TaskMessage result;
//anteroom.TryDequeue(out result);
InternalEmptyFlag = result == null;
return(result);
}
}
}
//public T GetItemFifo<T>()
// where T : TaskMessage
//{
// TaskMessage tmr = GetItemFifo();
// T tmo = Activator.CreateInstance<T>();
// tmo.SetHolder(tmr.Holder);
// return tmo;
//}
//public TaskMessage GetItemFifo()
//{
// CheckConnection();
// TaskQueue.TQItemSelector selector = TaskQueue.TQItemSelector.DefaultFifoSelector;
// var cursor = Collection.Find(MongoSelector.GetQuery(selector)).SetSortOrder();
// cursor.Limit = 1;
// MongoMessage mms = cursor.FirstOrDefault();
// if (mms == null)//empty
// return null;
// TaskMessage msg = new TaskMessage(mms.ExtraElements);
// msg.Holder.Add("__id", mms.id.Value);
// return msg;
//}
public TaskMessage GetItem()
{
CheckConnection();
var cursor = Collection.Find(QueryFeature).SetSortOrder(SortFeature);
cursor.Limit = 1;
MongoMessage mms = cursor.FirstOrDefault();
if (mms == null)//empty
return null;
TaskMessage msg = new TaskMessage(mms.ExtraElements);
msg.Holder.Add("__id", mms.id.Value);
return msg;
}
public TaskMessage Pop(string channel)
{
ChannelAnteroom ch = MessageChannels.GetAnteroom(channel);
TaskQueue.Providers.TaskMessage item = ch.Next();
if (item == null)
return null;
item.Processed = true;
item.ProcessedTime = DateTime.UtcNow;
ch.Update(item);
return item;
}
public bool Push(Dictionary<string, object> parameters, ref TaskMessage q_parameter)
{
System.Threading.Thread.Sleep(10);
return true;
//Send
SmtpModel smtp_p = new SmtpModel(parameters);
MailModel mail = new MailModel(q_parameter);
// send email
bool result = emailSender.Send(mail, smtp_p);
if (mail.SendErrors > 5)
result = true;
q_parameter = mail;
return result;
}
private int ConsumerEntry(QueueTask task)
{
//Console.WriteLine("consumer: {0}", task.ChannelName);
//QueueTask task = pi as QueueTask;
IBrokerModule mod = task.Module;
// Pop item from queue
ChannelAnteroom ch = task.Anteroom;//MessageChannels.GetAnteroom(task.ChannelName);
if (ch.InternalEmptyFlag)
{
return(1);
}
TaskQueue.Providers.TaskMessage message = ch.Next();
if (message == null)
{
return(1);
}
//if (message == null)
//{
// // this must be replaced with better way communication with message bus
// Console.WriteLine("Consumer empty, suspended: {0}", task.ChannelName);
// task.Suspended = true;
// return;
//}
TaskQueue.Providers.TaskMessage item = message;
bool updated = ((IModConsumer)mod.MI).Push(task.Parameters, ref message);
if (updated)
{
message.Processed = true;
message.ProcessedTime = DateTime.UtcNow;
}
updated = updated || (!Object.ReferenceEquals(item, message));// model is modified
if (updated)
{
ch.Update(message);
}
ch.ChannelStatsOut.inc(); // inc stats
return(0);
}
public bool pushMessage(Dictionary <string, object> msg)
{
// benchMessage
TaskQueue.Providers.TaskMessage tm = new TaskQueue.Providers.TaskMessage(msg);
//logger.Debug("put {0}", tm.MType);
bool result = false;
if (tm.MType != null)
{
try
{
result = broker.PushMessage(tm);
}
catch (Exception e)
{
logger.Exception(e, "message put", "error while message processing");
}
}
return(result);
}
public bool Push(Dictionary<string, object> parameters, ref TaskMessage q_parameter)
{
//Console.WriteLine(q_parameter.AddedTime.ToString());
//return false;
BenchModel pocket = new BenchModel(q_parameter);
pocket.ParameterA = "setA";
pocket.ParameterB = "setB";
//System.Threading.Thread.Sleep(2000);
//q_parameter = pocket; // for persistant only queues
//return true;
return false;
}
public bool Update(TaskMessage item)
{
try
{
Queue.UpdateItem(item);
}
catch (Exception e)
{
logger.Exception(e, "Message Update", "anteroom update error");
return false;
}
return true;
}
public bool Push(TaskMessage item)
{
try
{
Queue.Push(item);
InternalEmptyFlag = false;
}
catch (QueueOverflowException e)
{
logger.Exception(e, "Message Push", "anteroom push overflow queue error: {0}", e.baseException.Message);
InternalOverflowFlag = true;
return false;
}
catch (Exception e)
{
logger.Exception(e, "Message Push", "anteroom push error");
return false;
}
return true;
}
public BenchModel(TaskQueue.Providers.TaskMessage holder)
: base(holder.MType)
{
this.SetHolder(holder.GetHolder());
}
public bool pushMessage(Dictionary<string, object> msg)
{
// benchMessage
TaskQueue.Providers.TaskMessage tm = new TaskQueue.Providers.TaskMessage(msg);
//logger.Debug("put {0}", tm.MType);
bool result = false;
if (tm.MType != null)
{
try
{
result = broker.PushMessage(tm);
}
catch (Exception e)
{
logger.Exception(e, "message put", "error while message processing");
}
}
return result;
}
public void Push(TaskMessage item)
{
CheckConnection();
//WriteConcernResult result = Collection.Insert(new BsonDocument(item.GetHolder()), new MongoInsertOptions() { WriteConcern = new WriteConcern() { Journal = true } });
//WriteConcernResult result = Collection.Insert(new MongoMessage { ExtraElements = item.GetHolder() }, new MongoInsertOptions() { WriteConcern = new WriteConcern() { Journal = true } });
WriteConcernResult result = Collection.Insert(new MongoMessage { ExtraElements = item.GetHolder() });
// TODO: QueueOverflowException
if (!result.Ok)
throw new Exception("error in push to mongo queue: " + result.ToJson());
}
public void UpdateItem(TaskMessage item)
{
Dictionary<string, object> holder = item.GetHolder();
object id = holder["__id"];
if (id == null || !(id is ObjectId))
throw new Exception("__id of queue element is missing");
BsonObjectId objid = new BsonObjectId((ObjectId)id);
holder.Remove("__id");
MongoMessage msg = new MongoMessage
{
ExtraElements = holder,
id = objid
};
//var result = Collection.Save(msg, new MongoInsertOptions() { WriteConcern = new WriteConcern() { Journal = true } });
var result = Collection.Save(msg);
if (!result.Ok)
throw new Exception("error in update to mongo queue: " + result.ToJson());
}
public bool Push(Dictionary<string, object> parameters, ref TaskMessage q_parameter)
{
//Console.WriteLine(q_parameter.AddedTime.ToString());
//return false;
BenchModel pocket = new BenchModel(q_parameter);
pocket.ParameterA = "setA";
pocket.ParameterB = "setB";
if (pocket.WaitThreadMS > 0)//100 secmax
{
if (pocket.WaitThreadMS < 100000)
System.Threading.Thread.Sleep(pocket.WaitThreadMS);
else
logger.Warning("message has try to wait thread for more than 100sec, check arguments");
}
//q_parameter = pocket; // for persistant only queues
//return true;
return false;
}
public Providers.TaskMessage[] GetItemTuple()
{
lock (baseQueue)
if (baseQueue.Count > 0)
{
TaskMessage[] tuple;
if (maxTuple < baseQueue.Count)
{
tuple = new TaskMessage[maxTuple];
for (int i = 0; i < maxTuple; i++)
{
tuple[i] = baseQueue.Dequeue();
}
}
else
{
tuple = baseQueue.ToArray();
baseQueue.Clear();
}
return tuple;
}
else
{
return null;
}
}
public TaskMessage[] GetItemTuple()
{
var cursor = Collection.Find(QueryFeature).SetSortOrder(SortFeature).SetBatchSize(TupleSize);
cursor.Limit = TupleSize;
List<TaskMessage> tma = new List<TaskMessage>();
foreach (var mms in cursor)
{
TaskMessage msg = new TaskMessage(mms.ExtraElements);
msg.Holder.Add("__id", mms.id.Value);
tma.Add(msg);
}
return tma.ToArray();
}
public bool Check(System.Collections.Hashtable holder)
{
return(TaskMessage.CheckWithSelector(holder, selector));
}
public MessageComparerVMap(TQItemSelector selector)
{
Comparator = TaskMessage.MakeComparatorValueMap(selector);
Checker = TaskMessage.MakeCheckerDictionary(selector);
this.selector = selector;
}
public MessageType(TaskMessage model)
{
UniqueName = model.MType;
Model = new TaskQueue.RepresentedModel(model.GetType());
}
public Providers.TaskMessage[] GetItemTuple()
{
//lock (this)
// if (baseQueue.Count > 0)
// {
// TaskMessage[] tuple;
// if (maxTuple < baseQueue.Count)
// {
// tuple = new TaskMessage[maxTuple];
// for (int i = 0; i < maxTuple; i++)
// {
// tuple[i] = baseQueue.Dequeue();
// }
// }
// else
// {
// tuple = baseQueue.ToArray();
// baseQueue.Clear();
// }
// return tuple;
// }
// else
// {
// return null;
// }
lock (this)
{
if (MessageQueue.Count > 0)
{
TaskMessage[] tuple = null;
if (maxTuple < MessageQueue.Count)
{
tuple = new TaskMessage[maxTuple];
MessageQueue.CopyTo(tuple, 0, tuple.Length);
for (int i = 0; i < tuple.Length; i++)
{
TaskMessage em = tuple[i];
TaskMessage msg = new TaskMessage(em.Holder);
msg.Holder.Add("__original", em);
tuple[i] = msg;
MessageQueue.Remove(em);
}
}
else
{
tuple = new TaskMessage[MessageQueue.Count];
MessageQueue.CopyTo(tuple);
for (int i = 0; i < tuple.Length; i++)
{
TaskMessage em = tuple[i];
TaskMessage msg = new TaskMessage(em.Holder);
msg.Holder.Add("__original", em);
tuple[i] = msg;
}
MessageQueue.Clear();
}
return(tuple);
}
else
{
return(null);
}
}
}
