private bool ValidateItem()
{
string errorMessage = "";
bool isValid = true;
CoverMode type = CoverMode;
if (txtKey.TextLength == 0)
{
isValid = false;
errorMessage += "\r\nInvalid Queue name";
}
//switch (type)
//{
// case CoverMode.ItemsOnly:
// case CoverMode.ItemsAndLog:
// if (cbProvider.Text.Length == 0)
// {
// isValid = false;
// errorMessage += "\r\nInvalid Provider";
// }
// if (txtConnection.Text.Length == 0)
// {
// isValid = false;
// errorMessage += "\r\nInvalid Connection";
// }
// break;
//}
if (!string.IsNullOrEmpty(errorMessage))
{
MsgBox.ShowError(errorMessage);
}
return(isValid);
}
public PriorityFsQueue(QueueHost qp)
: base(qp.HostName)
{
int numProcs = Environment.ProcessorCount;
int concurrencyLevel = numProcs * 2;
int initialCapacity = 101;
QueueList = new ConcurrentDictionary <Ptr, IQueueItem>(concurrencyLevel, initialCapacity);
//CommitMode = qp.CommitMode;
//CoverMode = qp.Mode;
RootPath = qp.RootPath;
CommitMode = qp.CommitMode;
CoverMode = qp.CoverMode;
if (qp.CoverMode == CoverMode.FileStream)
{
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(qp);
m_fs.Logger = Logger;
//InitRecoverQueue();
//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)
{
Logger.Info("PriorityFsQueue will load items to : {0}", qp.HostName);
m_fs.ReloadItemsAsync(FolderType.Queue, 0, (IQueueItem item) =>
{
this.ReEnqueue(item);
});
}
else
{
Logger.Info("PriorityFsQueue will clear all items from : {0}", qp.HostName);
m_fs.ClearItems(FolderType.Queue);
}
}
}
/// <summary>
/// QProperties ctor
/// </summary>
/// <param name="queueName"></param>
/// <param name="isTrans"></param>
/// <param name="mode"></param>
public QProperties(string queueName, bool isTrans, CoverMode mode)
{
ServerPath = "localhost";
QueueName = queueName;
Mode = mode;
IsTrans = isTrans;
MaxRetry = DefaultMaxRetry;
ReloadOnStart = false;
}
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>
/// QProperties ctor
/// </summary>
/// <param name="queueName"></param>
/// <param name="isTrans"></param>
/// <param name="mode"></param>
public QProperties(string queueName, bool isTrans, CoverMode mode)
{
ServerPath = "localhost";
QueueName = queueName;
Mode = mode;
IsTrans = isTrans;
MaxRetry = DefaultMaxRetry;
ReloadOnStart = false;
IsTopic = false;
TargetPath = null;
CommitMode = PersistCommitMode.None;
}
public IQueueItem AddQueue(CoverMode mode, bool isTrans, bool isTopic)
{
QProperties qp = new QProperties()
{
QueueName = _QueueName,
ServerPath = "localhost",
Mode = mode,
IsTrans = isTrans,
MaxRetry = QueueDefaults.DefaultMaxRetry,
ReloadOnStart = false,
ConnectTimeout = 0,
TargetPath = "",
IsTopic = isTopic
};
return(AddQueue(qp));
//var message = new QueueItem()
//{
// Host = _QueueName,
// Command = QueueCmd.AddQueue,
//};
//message.SetBody(qp.GetEntityStream(false), qp.GetType());
//GenericNameValue header = new GenericNameValue();
//header.Add("QueueName", _QueueName);
//header.Add("ServerPath", "localhost");
//header.Add("Mode", (int)mode);
//header.Add("IsTrans", isTrans);
//header.Add("MaxRetry", QueueDefaults.DefaultMaxRetry);
//header.Add("ReloadOnStart", false);
//message.SetHeader(header);
//message.SetBody(qp);
//var response=base.SendDuplex(message);
//return response;// == null ? null : response.ToMessage();
//ReportApi client = new ReportApi(QueueDefaults.QueueManagerPipeName, true);
//var res= client.Exec(message, QueueCmd.AddQueue);
//return (Message)res;// client.Exec(message, QueueCmd.AddQueue);
}
/// <summary>Creates a transactional or non-transactional Message Queuing queue at the specified path.</summary>
/// <returns>A <see cref="T:Nistec.Messaging.MQueue"></see> that represents the new queue.</returns>
/// <param name="queueName">The path of the queue to create. </param>
/// <param name="isTrans">true to create a transactional queue; false to create a non-transactional queue. </param>
/// <param name="mode">One of the <see cref="CoverMode"/> options.</param>
public MQueue AddQueue(string queueName, bool isTrans, CoverMode mode)
{
if (queueName == null)
{
throw new ArgumentNullException("queueName");
}
if (queueName.Length == 0)
{
throw new ArgumentException("InvalidParameter", "queueName");
}
if (MQ.ContainsKey(queueName))
{
return((MQueue)MQ[queueName]);
}
//CoverMode mode= CoverMode.None;
//if (!string.IsNullOrEmpty(Connection) && QueueProvider > QueueProvider.None)
//{
// mode= CoverMode.ItemsOnly;
//}
return(AddQueue(new QProperties(queueName, isTrans, mode)));
}
/// <summary>
/// MQueue Ctor
/// </summary>
/// <param name="mqp"></param>
public MQueue(IQProperties prop)
{
Logger = QLogger.Logger.ILog;
Console.WriteLine("Init MQueue " + prop);
LogActionInfo("MQueue ctor", "Init MQueue " + prop.Print());
TimeStarted = DateTime.Now;
LOCK();
m_enabled = true;
//m_Server = prop.Server;
m_QueueName = prop.QueueName;
m_CoverMode = prop.Mode;
m_maxRetry = prop.MaxRetry;
m_isTrans = prop.IsTrans;
IsTopic = prop.IsTopic;
TargetPath = prop.TargetPath;
RoutHost = prop.GetRoutHost();
if (IsCoverable)
{
//_QCover = new QCover()
//{
// ConnectTimeout = prop.ConnectTimeout,
// CoverProvider = IsDbQueue ? CoverProviders.Db : CoverProviders.File,
// CoverPath = prop.CoverPath
//};
m_QueuesPath = AgentManager.Settings.QueuesPath;
}
if (IsTopic)
{
Topic = new TopicController(this);
}
resetEvent = new ManualResetEvent(false);
m_Perfmon = new QueuePerformanceCounter(this, QueueAgentType.MQueue, m_QueueName);
//Q = prop.Factory();
Q = new PriorityComplexQueue(prop);
Q.Logger = Logger;
Q.MessageArrived += new QueueItemEventHandler(Q_MessageArrived);
Q.MessageReceived += new QueueItemEventHandler(Q_MessageReceived);
Q.TransactionBegin += new QueueItemEventHandler(Q_MessageTransBegin);
Q.TransactionEnd += new QueueItemEventHandler(Q_MessageTransEnd);
Q.ErrorOccured += new QueueItemEventHandler(Q_ErrorOccured);
//InitRecoverQueue(DefaultIntervalMinuteRecover);
if (prop.ReloadOnStart)
{
Q.ReloadItemsInternal();
}
UNLOCK();
//if (recoverable)
//{
// InitRecoverQueue(DefaultIntervalMinuteRecover);
//}
//else
//{
// UNLOCK();
//}
}
///// <summary>
///// ValidateHoldItems
///// </summary>
//public void ValidateHoldItems()
//{
// if (HoldItemsCount() > 0)
// {
// if (Q.TotalCount < MinCapacity && !HoldEnqueue)
// {
// HoldItemsEnqueue(CapacityReEnqueue);
// }
// }
//}
/// <summary>
/// SetProperty
/// </summary>
/// <param name="propertyName"></param>
/// <param name="propertyValue"></param>
public void SetProperty(string propertyName, object propertyValue)
{
switch (propertyName)
{
//case "MaxItemsPerSecond":
// MaxItemsPerSecond = Types.ToInt(propertyValue, MaxItemsPerSecond);
// break;
//case "EnqueueWait":
// EnqueueWait = Types.ToInt(propertyValue, EnqueueWait);
// break;
//case "DequeueWait":
// DequeueWait = Types.ToInt(propertyValue, DequeueWait);
// break;
//case "UseThreadSettings":
// UseThreadSettings = Types.ToBool(propertyValue, UseThreadSettings);
// break;
//case "SerializeBody":
// SerializeBody = Types.ToBool(propertyValue, SerializeBody);
// break;
//case "HoldInterval":
// HoldInterval = Types.ToInt(propertyValue, HoldInterval);
// break;
//case "CapacityReEnqueue":
// CapacityReEnqueue = Types.ToInt(propertyValue, CapacityReEnqueue);
// break;
//case "DateFormat":
// DateFormat = Types.NZ(propertyValue, DateFormat);
// break;
//case "LogItems":
// LogItems = Types.ToBool(propertyValue, LogItems);
// break;
case "HoldDequeue":
HoldDequeue = Types.ToBool(propertyValue, HoldDequeue);
break;
case "HoldEnqueue":
HoldEnqueue = Types.ToBool(propertyValue, HoldEnqueue);
break;
case "Enabled":
Enabled = Types.ToBool(propertyValue, Enabled);
break;
case "MaxCapacity":
MaxCapacity = Types.ToInt(propertyValue, MaxCapacity);
break;
//case "MinCapacity":
// MinCapacity = Types.ToInt(propertyValue, MinCapacity);
// break;
case "Collate":
Collate = Types.NZ(propertyValue, Collate);
break;
case "IsTrans":
m_isTrans = Types.ToBool(propertyValue, IsTrans);
break;
case "MaxRetry":
m_maxRetry = (byte)Types.ToInt(propertyValue, MaxRetry);
break;
case "Mode":
m_CoverMode = (CoverMode)Types.ParseEnum(typeof(CoverMode), propertyValue.ToString(), CoverMode.Memory);
break;
//case "Provider":
// m_Provider = (QueueProvider)Types.ParseEnum(Provider.GetType(), propertyValue.ToString(), Provider);
// break;
//case "Server":
// m_Server = Types.ToInt(propertyValue, Server);
// break;
default:
return;
}
}
