private bool ManageTimedJobs(QMSite site)
{
bool enqueued = false;
if (site.basePath != string.Empty)
{
string sXML = BuildProductInfoString(site);
try
{
//var s = InvokeComObject(site, "ManageTimerJobs");
using (var qm = new QueueManager(sXML))
{
int result = qm.ManageTimedJobs();
if (result == (int)StatusEnum.rsSuccess)
{
enqueued = ManageQueueJobs(site);
}
}
}
catch (Exception ex)
{
new LogService(sXML).TraceStatusError("ManageTimedJobs - " + site.basePath, (StatusEnum)100, ex);
ExceptionHandler("ManageTimedJobs - " + site.basePath, ex);
}
}
return(enqueued);
}
void EnqueueSite(QMSite site, Guid jobId, string contextData, DateTime submitted, bool prioritize)
{
lock (longRunQueueLock)
{
int index = longRunQueue.Select(x => x.Item1).ToList().IndexOf(site);
while (index >= 0 && !longRunQueue[index].Item2.Equals(jobId))
{
index = longRunQueue.Select(x => x.Item1).ToList().IndexOf(site, index + 1);
}
if (index < 0)
{
longRunQueue.Add(new Tuple <QMSite, Guid, String, DateTime, bool>(site, jobId, contextData, submitted, prioritize));
}
}
}
private bool ManageQueueJobs(QMSite site, bool prioritize = false)
{
bool enqueued = false;
if (site != null)
{
lock (_locks.GetOrAdd(site.basePath.ToLower(), s => new object()))
{
string sXML = BuildProductInfoString(site);
try
{
// check the queue for .net items before using RSVP
using (var qm = new QueueManager(sXML))
{
while (qm.ReadNextQueuedItem(GetExclusionList(site)))
{
new LogService(sXML).TraceLog("ManageQueueJobs", (StatusEnum)0, "Queue Manager Next item found for site : " + site.basePath);
// we have a queued item - try to handle it in portfolioenginecore first
if (!qm.ManageQueue()) // false means not handled
{
switch (qm.Context)
{
case 200:
//////PortfolioEngineAPI pFeAPI = new PortfolioEngineAPI();
//////pFeAPI.Execute("RefreshRoles", "");
//////pFeAPI.Dispose();
qm.SetJobCompleted();
ErrorHandler("ManageQueueJobs Case 200", 98765);
break;
default:
EnqueueSite(site, qm.guidJob, qm.ContextData, qm.Submitted, prioritize);
enqueued = true;
break;
}
}
}
}
}
catch (Exception ex)
{
new LogService(sXML).TraceStatusError("ManageQueue exception thrown for " + site.basePath, (StatusEnum)99, ex);
ExceptionHandler("ManageQueueJobs - " + site.basePath, ex);
}
}
}
return(enqueued);
}
private string BuildProductInfoString(QMSite site)
{
CStruct xEPKServer = new CStruct();
xEPKServer.Initialize("EPKServer");
xEPKServer.CreateString("basepath", site.basePath);
//xEPKServer.CreateString("Port", port);
xEPKServer.CreateString("dbcnstring", site.connection);
xEPKServer.CreateString("username", site.userName);
xEPKServer.CreateString("WResID", site.WRES_ID);
xEPKServer.CreateString("pid", site.pid);
xEPKServer.CreateString("session", site.SessionInfo);
xEPKServer.CreateString("ActiveTraceChannels", site.ActiveTraceChannels);
//xEPKServer.CreateString("ProductFlags", site.);
return(xEPKServer.XML());
}
string GetExclusionList(QMSite matchSite)
{
string exclusion = "";
lock (longRunQueueLock)
{
for (int i = 0; i < longRunQueue.Count; i++)
{
if (longRunQueue[i].Item1.basePath.Equals(matchSite.basePath, StringComparison.OrdinalIgnoreCase))
{
exclusion += "'" + longRunQueue[i].Item2 + "',";
}
}
}
if (!string.IsNullOrWhiteSpace(exclusion))
{
exclusion = exclusion.Substring(0, exclusion.Length - 1);
}
return(exclusion);
}
private void BuildSitesList()
{
try
{
List <QMSite> newSites = new List <QMSite>();
string basepaths = "";
string sNTUserName = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
RegistryKey rk = Registry.LocalMachine.OpenSubKey(const_subKey);
if (rk != null)
{
string[] m_sBasePathSubkeys = rk.GetSubKeyNames();
rk.Close();
foreach (string sBasePath in m_sBasePathSubkeys)
{
string basePath = sBasePath.Trim();
try
{
if (!string.IsNullOrEmpty(basePath))
{
rk = Registry.LocalMachine.OpenSubKey(const_subKey + basePath);
if (rk != null)
{
QMSite site = null;
if (rk.GetValue("QMActive", "no").ToString().ToLower() == "yes")
{
site = new QMSite();
site.basePath = basePath;
var dbConnectionStringBuilder = new DbConnectionStringBuilder {
ConnectionString = rk.GetValue("ConnectionString", string.Empty).ToString().Trim()
};
dbConnectionStringBuilder.Remove("Provider");
site.connection = dbConnectionStringBuilder.ToString();
site.pid = rk.GetValue("PID", string.Empty).ToString().Trim();
site.cn = rk.GetValue("CN", string.Empty).ToString().Trim();
int nDefaultTraceChannels = 0;
Int32.TryParse(rk.GetValue("Trace", 0).ToString(), out nDefaultTraceChannels);
site.ActiveTraceChannels = nDefaultTraceChannels.ToString();
}
rk.Close();
if (site != null)
{
using (var m_oConnection = new SqlConnection())
{
m_oConnection.ConnectionString = site.connection + ";Application Name=PfEQueueManager";
m_oConnection.Open();
using (SqlCommand cmd = new SqlCommand("SELECT WRES_ID,RES_NAME,WRES_TRACE FROM EPG_RESOURCES WHERE WRES_CAN_LOGIN = 1 AND WRES_USE_NT_LOGON = 1 AND WRES_NT_ACCOUNT=@WRES_NT_ACCOUNT", m_oConnection))
{
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue("@WRES_NT_ACCOUNT", sNTUserName.ToLower());
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader != null)
{
if (reader.Read())
{
site.WRES_ID = reader["WRES_ID"].ToString();
site.userName = reader["RES_NAME"].ToString();
site.NTAccount = sNTUserName.ToLower();
site.SessionInfo = Guid.NewGuid().ToString().ToUpper();
}
}
}
}
}
newSites.Add(site);
if (!string.IsNullOrEmpty(basepaths))
{
basepaths += ",";
}
basepaths += basePath.Trim();
}
}
}
}
catch (Exception ex)
{
ExceptionHandler("BuildSitesList for basepath '" + basePath + "'", ex);
}
}
}
lock (sitesLock)
{
m_sites = newSites;
m_basepaths = basepaths;
}
}
catch (Exception ex)
{
ExceptionHandler("BuildSitesList", ex);
}
}
void DoLongRun()
{
List <Tuple <QMSite, Guid, DateTime, CancellationTokenSource, Task, int> > processingJobs = new List <Tuple <QMSite, Guid, DateTime, CancellationTokenSource, Task, int> >();
DateTime sitesLastCheck = DateTime.Now;
DateTime queuedLastCheck = DateTime.Now;
DateTime timedLastCheck = DateTime.Now;
while (!token.IsCancellationRequested)
{
//BUILD SITES
try
{
DateTime sitesNewCheck = DateTime.Now;
if (sitesNewCheck - sitesLastCheck > buildSitesPeriod)
{
sitesLastCheck = sitesNewCheck;
BuildSitesList();
}
}
catch (Exception ex)
{
ExceptionHandler("BuildingSites", ex);
}
//QUEUING
try
{
DateTime queuedNewCheck = DateTime.Now;
if (queuedNewCheck - queuedLastCheck > queueJobsPeriod)
{
queuedLastCheck = queuedNewCheck;
string basepaths;
List <QMSite> sites = GetSites(out basepaths);
if (!string.IsNullOrEmpty(basepaths))
{
MessageHandler("Refresh", "Refresh site list",
"active basePaths :\n" + basepaths.Replace(',', '\n'));
}
if (sites != null)
{
foreach (QMSite site in sites)
{
ManageQueueJobs(site);
}
}
}
}
catch (Exception ex)
{
ExceptionHandler("QueuingJobs", ex);
}
try
{
DateTime timedNewCheck = DateTime.Now;
if (timedNewCheck - timedLastCheck > timedJobsPeriod)
{
timedLastCheck = timedNewCheck;
string basepaths;
List <QMSite> sites = GetSites(out basepaths);
if (sites != null)
{
foreach (QMSite site in sites)
{
string sXML = BuildProductInfoString(site);
new LogService(sXML).TraceLog("ServiceTimer_Tick", 0, "");
ManageTimedJobs(site);
}
}
}
}
catch (Exception ex)
{
ExceptionHandler("TimingJobs", ex);
}
kickOffLongWorkEvent.WaitOne(mainLoopPeriod);
//REORDER
lock (longRunQueueLock)
{
List <Tuple <QMSite, Guid, String, DateTime, bool> > newList = longRunQueue.GetRange(processingJobs.Count, longRunQueue.Count - processingJobs.Count);
longRunQueue.RemoveRange(processingJobs.Count, newList.Count);
longRunQueue.AddRange(newList.OrderByDescending(x => x.Item5).ThenBy(x => x.Item4).ToArray());
}
//PROCESSING
while (processingJobs.Count < maxThreadCount && processingJobs.Count < longRunQueue.Count)
{
QMSite site = longRunQueue[processingJobs.Count].Item1;
Guid jobId = longRunQueue[processingJobs.Count].Item2;
string contextData = longRunQueue[processingJobs.Count].Item3;
if (contextData.Contains("<EPKProcess>") && processingJobs.Count >= maxThreadCount - reserveSeats)
{
//string sXML = BuildProductInfoString(site);
//using (var qm = new QueueManager(sXML))
//{
// qm.RequeueJob(jobId);
//}
lock (longRunQueueLock)
{
longRunQueue.RemoveAt(processingJobs.Count);
}
continue;
}
CancellationTokenSource tokenSource = new CancellationTokenSource();
Task newJob = Task.Factory.StartNew((object obj) =>
{
try
{
var data = (dynamic)obj;
using (tokenSource.Token.Register(Thread.CurrentThread.Abort))
{
WSSAdmin wssadmin = new WSSAdmin();
var result = wssadmin.RSVPRequest("ManageQueue", data.basePath, data.jobId.ToString());
return(true);
}
}
catch (ThreadAbortException)
{
return(false);
}
}, new { basePath = site.basePath, jobId = jobId }, tokenSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
processingJobs.Add(new Tuple <QMSite, Guid, DateTime, CancellationTokenSource, Task, int>(site, jobId, DateTime.Now, tokenSource, newJob, processingJobs.Count));
}
//service shutdown
if (token.IsCancellationRequested)
{
foreach (var job in processingJobs)
{
job.Item4.Cancel();
string sXML = BuildProductInfoString(job.Item1);
using (var qm = new QueueManager(sXML))
{
qm.RequeueJob(job.Item2);
}
}
processingJobs.Clear();
break;
}
//Check completion
List <Task> jobs = processingJobs.Select(x => x.Item5).ToList();
List <int> completedJobsIndex = new List <int>();
int completedJobIndex = Task.WaitAny(jobs.ToArray(), completionPollPeriod);
if (completedJobIndex >= 0)
{
completedJobsIndex.Add(processingJobs[completedJobIndex].Item6);
processingJobs.RemoveAt(completedJobIndex);
for (int i = completedJobIndex; i < processingJobs.Count; i++)
{
processingJobs[i] = new Tuple <QMSite, Guid, DateTime, CancellationTokenSource, Task, int>(processingJobs[i].Item1, processingJobs[i].Item2, processingJobs[i].Item3, processingJobs[i].Item4, processingJobs[i].Item5, processingJobs[i].Item6 - 1);
}
}
else if (processingJobs.Count >= 1 && (DateTime.Now - processingJobs[0].Item3) > jobMaxTimeout && !processingJobs[0].Item5.IsCompleted && longRunQueue.Count > processingJobs.Count)
{
processingJobs[0].Item4.Cancel();
string sXML = BuildProductInfoString(processingJobs[0].Item1);
using (var qm = new QueueManager(sXML))
{
qm.RequeueJob(processingJobs[0].Item2);
}
completedJobsIndex.Add(processingJobs[0].Item6);
processingJobs.RemoveAt(0);
for (int i = 0; i < processingJobs.Count; i++)
{
processingJobs[i] = new Tuple <QMSite, Guid, DateTime, CancellationTokenSource, Task, int>(processingJobs[i].Item1, processingJobs[i].Item2, processingJobs[i].Item3, processingJobs[i].Item4, processingJobs[i].Item5, processingJobs[i].Item6 - 1);
}
}
//remove completions from queue
if (completedJobsIndex.Any())
{
completedJobsIndex.Sort();
lock (longRunQueueLock)
{
for (int i = completedJobsIndex.Count - 1; i >= 0; i--)
{
longRunQueue.RemoveAt(completedJobsIndex[i]);
}
}
}
}
}
