public int Initialize()
{
int rc = -99;
try
{
SetLogID(1);
myConfigs = XTRMObject.getDictionaryEntries("XLatorConfigFile");
rc = myConfigs.Count;
}
catch (Exception ex)
{
XLogger(1175, -1, string.Format("Exception in Initialize(); message={0}", ex.Message));
rc = -1;
}
return(rc);
}
public int Initialize()
{
int rc = -99;
try
{
//int rc = 0;
SetLogID(1);
//string XLatorConfigFile = XLib.XDB_Objects.XObject.getDictionaryEntry("XLatorConfigFile");
myConfigs = XTRMObject.getDictionaryEntries("XLatorConfigFile");
//myConfigLoader.ParseConfig(XLatorConfigFile, 2, true);
rc = myConfigs.Count;
}
catch (Exception ex)
{
XLogger(1175, -1, string.Format("Exception in Initialize(); message={0}", ex.Message));
rc = -1;
}
return(rc);
}
public int Initialize()
{
int rc = 0;
_pool = new Semaphore(1, 1);
Clear();
SetLogID(3);
myConfigs = XTRMObject.getDictionaryEntries("XAgentConfigFile");
// Read file, call parseConfig, then iterate around addPath().
foreach (string thisAgentFile in myConfigs)
{
// Read each file
ParseConfig(ResolveText(thisAgentFile, XDictionary), true);
//ParseConfig(thisAgentFile, true);
}
foreach (XTRMFSEntity thisEntity in entities)
{
// addEntity
addEntity(thisEntity);
}
return(rc);
}
public int Traverse(string candidatePath, string filePattern, string WorkspacePrefix, string DepotPrefix)
{
int rc = -1;
try
{
XLogger(51002, 0, string.Format("Execute XTroll.exe"));
myConfigs = XTRMObject.getDictionaryEntries("XTRMRootConfigFile");
myConfigLoaders.Clear();
foreach (string thisConfig in myConfigs)
{
XTRMRoot thisLoader = new XTRMRoot(ResolveText(thisConfig, XDictionary));
thisLoader.ParseConfig(2, true);
myConfigLoaders.Add(thisLoader);
}
var fileEntries = Directory.EnumerateFiles(candidatePath, filePattern, SearchOption.AllDirectories);
foreach (string sourceFile in fileEntries)
{
string thisFile = sourceFile.Replace(WorkspacePrefix, DepotPrefix);
thisFile = thisFile.Replace(@"\", @"/");
//if (stopFlag.Equals(1))
//{
// throw new Exception("EggTimer Expired!");
//}
// Try to Validate the Component and Element.
// If Element is valid, then skip (only looking for new elements).
// Fabricate Event Object for Element.
// Instantiate and Call Monitor to Identify Jobs.
//XMonitorCore myMonitor = new XMonitorCore();
XTRMMatchMaker myEventChecker = new XTRMMatchMaker();
// XTRMEvent Retrieved Successfully!
XTRMEvent thisEvent = new XTRMEvent(true);
thisEvent.Initialize(-1);
// <XTRMEvent ID="626">
// <Source>P4V</Source>
// <Action>edit</Action>
// <DateStamp>20120103 19:23:03</DateStamp>
// <User>shlori</User>
// <PIN>A342158B864EE75025C6F08F42C9544A</PIN>
// <Status>0</Status>
// <Path>//depot/main/product/doc/Portable/English/*</Path>
// <Desc>Fixed page/line breaks.</Desc>
// <!-- Parm1 = {Depot File} -->
// <Parm1>//depot/main/product/doc/Portable/English/Basic Analysis and Graphing.pdf</Parm1>
// <!-- Parm2 = {Depot Version} -->
// <Parm2>56</Parm2>
// <!-- Parm3 = {Change List} -->
// <Parm3>83234</Parm3>
// <!-- Parm4 = {File Type} -->
// <Parm4>binary+lm</Parm4>
// <!-- Parm5 = {File Size} -->
// <Parm5>4216714</Parm5>
// <!-- Parm6 = {Client} -->
// <Parm6>shlori-Win</Parm6>
// <!-- Parm7 = {SCM Time} -->
// <Parm7>1325636582</Parm7>
// </XTRMEvent>
thisEvent.eventAction = "edit";
thisEvent.eventDate = DateTime.Now.ToString();
thisEvent.eventSource = "P4V";
thisEvent.eventUser = "******";
thisEvent.eventState = -1;
thisEvent.eventParm1 = thisFile;
int eventState = 0;
bool eventFlag = false;
foreach (XTRMRoot thisLoader in myConfigLoaders)
{
//rc = myMonitor.EvaluateEvent(thisLoader, thisEvent);
List <XTRMJob> theseJobs = new List <XTRMJob>();
rc = myEventChecker.FindXMatch(thisLoader, thisEvent, out theseJobs);
if (rc > 0)
{
if (theseJobs.Count > 0)
{
foreach (XTRMJob thisJob in theseJobs)
{
Dictionary <string, string> jobData = new Dictionary <string, string>();
try
{
foreach (KeyValuePair <string, string> kvp in thisJob.config)
{
//saveJobData(jobSerial, kvp.Key.ToString().ToUpper(), kvp.Value);
jobData[kvp.Key.ToString().ToUpper()] = kvp.Value;
}
foreach (KeyValuePair <string, string> kvp in myEventChecker.dynConfig)
{
//saveJobData(jobSerial, kvp.Key.ToString().ToUpper(), kvp.Value);
jobData[kvp.Key.ToString().ToUpper()] = kvp.Value;
}
}
catch (Exception ex)
{
XLogger(1157, -1, string.Format("Saving Job Data; Message={0}", ex.Message));
}
try
{
if (validateInventory())
{
eventFlag = true;
}
}
catch (Exception)
{
eventFlag = false;
}
}
}
}
if (rc >= 0)
{
eventState += rc;
}
else
{
XLogger(1103, -1, string.Format("Execute::XTRMEvent.EvaluateEvent() Failure; UUID={1}; rc={2}", thisEvent.eventUUID, rc));
}
}
// If no jobs, then skip.
if (eventFlag)
{
// Creating the event will result in the Monitor processing against the production Config Loaders.
rc = thisEvent.Save();
if (rc < 0)
{
// Error!
}
}
// Otherwise, try to Validate the Component and Element Again.
// If Element is valid, then skip (only looking for new elements).
// Call Monitor to Create Jobs.
}
}
catch (Exception ex)
{
Console.Write(ex.Message);
XLogger(51003, -1, string.Format("XTroll Exception in Execute(); Message={0}.", ex.Message));
}
return(rc);
}
public int CheckEvents(string strPendingEventFolder)
{
int rc = 0;
int maxEventFileSize = 100000;
string[] fileEntries = { strPendingEventFolder };
XTRMEvent eventTester = new XTRMEvent(false);
List <string> myConfigs = new List <string>();
// We load each XTRMRoot Config File (once) and hold on to it for repeated use both in the loading of events (from XML) and in the evaluation of XDB events.
List <XTRMRoot> myConfigLoaders = new List <XTRMRoot>();
XmlWriter myCheckedEvent;
// For Each File in the folder, need to consume into XTRMEvent(s).
try
{
if (File.Exists(strPendingEventFolder))
{
//fileEntries = strPendingEventFolder;
}
else if (Directory.Exists(strPendingEventFolder))
{
fileEntries = Directory.GetFiles(strPendingEventFolder);
}
else
{
//Error
rc = -1;
}
}
catch (Exception ex)
{
}
try
{
myConfigs = XTRMObject.getDictionaryEntries("XTRMRootConfigFile");
myConfigLoaders.Clear();
foreach (string thisConfig in myConfigs)
{
XTRMRoot thisLoader = new XTRMRoot(ResolveText(thisConfig, XDictionary));
thisLoader.ParseConfig(2, true);
myConfigLoaders.Add(thisLoader);
}
}
catch (Exception ex)
{
}
try
{
foreach (string fileName in fileEntries)
{
try
{
// Only process file if it is less than 100KB.
FileInfo myInfo = new FileInfo(fileName);
if (myInfo.Length <= maxEventFileSize)
{
//ParseConfig(fileName);
XTRMRoot myEventLoader = new XTRMRoot(fileName);
//myEventLoader.Clear();
myEventLoader.ParseConfig(2, true);
// Going to write the same file with comments.
// OK, proceed!
XmlWriterSettings settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = false;
settings.ConformanceLevel = ConformanceLevel.Document;
settings.CloseOutput = true;
settings.Indent = true;
settings.Encoding = Encoding.Unicode;
myCheckedEvent = XmlWriter.Create(fileName, settings);
myCheckedEvent.WriteStartDocument();
myCheckedEvent.WriteStartElement("XTRMRoot");
// This will result in 0 or more XTRMEvents to process.
foreach (XTRMEvent thisEvent in myEventLoader.events)
{
try
{
myCheckedEvent.WriteStartElement("XTRMEvent");
myCheckedEvent.WriteAttributeString("ID", thisEvent.eventSerial.ToString());
myCheckedEvent.WriteWhitespace("\n");
// Check the Event!
foreach (XTRMRoot thisLoader in myConfigLoaders)
{
List <XTRMJob> theseJobs = new List <XTRMJob>();
rc = FindXMatch(thisLoader, thisEvent, out theseJobs);
if (rc > 0)
{
if (theseJobs.Count > 0)
{
foreach (XTRMJob thisJob in theseJobs)
{
myCheckedEvent.WriteComment(string.Format("CONFIG = {0} ------ FOLLOWING JOB MATCHED ------", thisLoader.name));
myCheckedEvent.WriteWhitespace("\n");
if (thisLoader.configFile.Length > 0)
{
myCheckedEvent.WriteComment(string.Format("FILE = {0}", thisLoader.configFile));
myCheckedEvent.WriteWhitespace("\n");
}
if (thisLoader.includeFile.Length > 0)
{
myCheckedEvent.WriteComment(string.Format("INCLUDE = {0}", thisLoader.includeFile));
myCheckedEvent.WriteWhitespace("\n");
}
// Display the Job Information and other info (job data) depending upon detail requested.
// Add to XML Output as Comments.
if (thisJob.containingComponent.Length > 0)
{
myCheckedEvent.WriteComment(string.Format("XComponent = {0}", thisJob.containingComponent));
myCheckedEvent.WriteWhitespace("\n");
}
if (thisJob.containingElement.Length > 0)
{
myCheckedEvent.WriteComment(string.Format("XElement = {0}", thisJob.containingElement));
myCheckedEvent.WriteWhitespace("\n");
}
if (thisJob.containingToolkit.Length > 0)
{
myCheckedEvent.WriteComment(string.Format("XToolkit = {0}", thisJob.containingToolkit));
myCheckedEvent.WriteWhitespace("\n");
}
if (thisJob.containingWorkflow.Length > 0)
{
myCheckedEvent.WriteComment(string.Format("XWorkflow = {0}", thisJob.containingWorkflow));
myCheckedEvent.WriteWhitespace("\n");
}
string strComment = "Job Name :\t";
strComment += thisJob.jobName;
myCheckedEvent.WriteComment(strComment);
myCheckedEvent.WriteWhitespace("\n");
foreach (XTRMTask thisTask in thisJob.tasks)
{
strComment = string.Format("\tTask Name : \t {0}", thisTask.taskName);
myCheckedEvent.WriteComment(strComment);
myCheckedEvent.WriteWhitespace("\n");
strComment = string.Format("\tTask Exec : \t {0}", thisTask.taskExecutable);
myCheckedEvent.WriteComment(strComment);
myCheckedEvent.WriteWhitespace("\n");
int count = 1;
foreach (string thisParm in thisTask.parms)
{
strComment = string.Format("\t\t<Parm{0}>\t = \t {1} ", count++, thisParm);
myCheckedEvent.WriteComment(strComment);
myCheckedEvent.WriteWhitespace("\n");
}
}
Dictionary <string, string> jobData = new Dictionary <string, string>();
try
{
myCheckedEvent.WriteComment("STATIC JOB DATA ------");
myCheckedEvent.WriteWhitespace("\n");
foreach (KeyValuePair <string, string> kvp in thisJob.config)
{
//saveJobData(jobSerial, kvp.Key.ToString().ToUpper(), kvp.Value);
jobData[kvp.Key.ToString().ToUpper()] = kvp.Value;
strComment = string.Format("\t\t<{0}>\t=\t{1} ", kvp.Key.ToString().ToUpper(), kvp.Value);
myCheckedEvent.WriteComment(strComment);
myCheckedEvent.WriteWhitespace("\n");
}
myCheckedEvent.WriteComment("DYNAMIC JOB DATA ------");
myCheckedEvent.WriteWhitespace("\n");
foreach (KeyValuePair <string, string> kvp in dynConfig)
{
//saveJobData(jobSerial, kvp.Key.ToString().ToUpper(), kvp.Value);
jobData[kvp.Key.ToString().ToUpper()] = kvp.Value;
strComment = string.Format("\t\t<{0}>\t=\t{1} ", kvp.Key.ToString().ToUpper(), kvp.Value);
myCheckedEvent.WriteComment(strComment);
myCheckedEvent.WriteWhitespace("\n");
}
myCheckedEvent.WriteComment("------------------------------------------------------------------");
myCheckedEvent.WriteWhitespace("\n");
}
catch (Exception ex)
{
XLogger(1157, -1, string.Format("Saving Job Data; Message={0}", ex.Message));
}
}
myCheckedEvent.WriteComment("*** END MATCHES ------");
myCheckedEvent.WriteWhitespace("\n");
}
else
{
myCheckedEvent.WriteComment("NO JOBS MATCHED ------");
myCheckedEvent.WriteWhitespace("\n");
}
}
else
{
myCheckedEvent.WriteComment("NO MATCHES ------");
myCheckedEvent.WriteWhitespace("\n");
}
}
myCheckedEvent.WriteStartElement("Source");
myCheckedEvent.WriteString(thisEvent.eventSource);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
myCheckedEvent.WriteStartElement("Action");
myCheckedEvent.WriteString(thisEvent.eventAction);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
myCheckedEvent.WriteStartElement("DateStamp");
myCheckedEvent.WriteString(thisEvent.eventDate);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
myCheckedEvent.WriteStartElement("User");
myCheckedEvent.WriteString(thisEvent.eventUser);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
myCheckedEvent.WriteStartElement("PIN");
myCheckedEvent.WriteString(thisEvent.eventUUID);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
myCheckedEvent.WriteStartElement("Status");
myCheckedEvent.WriteString("0");
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
if (thisEvent.eventParm1 != null)
{
if (thisEvent.eventParm1.Length > 0)
{
myCheckedEvent.WriteStartElement("Parm1");
myCheckedEvent.WriteString(thisEvent.eventParm1);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
}
}
if (thisEvent.eventParm2 != null)
{
if (thisEvent.eventParm2.Length > 0)
{
myCheckedEvent.WriteStartElement("Parm2");
myCheckedEvent.WriteString(thisEvent.eventParm2);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
}
}
if (thisEvent.eventParm3 != null)
{
if (thisEvent.eventParm3.Length > 0)
{
myCheckedEvent.WriteStartElement("Parm3");
myCheckedEvent.WriteString(thisEvent.eventParm3);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
}
}
if (thisEvent.eventParm4 != null)
{
if (thisEvent.eventParm4.Length > 0)
{
myCheckedEvent.WriteStartElement("Parm4");
myCheckedEvent.WriteString(thisEvent.eventParm4);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
}
}
if (thisEvent.eventParm5 != null)
{
if (thisEvent.eventParm5.Length > 0)
{
myCheckedEvent.WriteStartElement("Parm5");
myCheckedEvent.WriteString(thisEvent.eventParm5);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
}
}
if (thisEvent.eventParm6 != null)
{
if (thisEvent.eventParm6.Length > 0)
{
myCheckedEvent.WriteStartElement("Parm6");
myCheckedEvent.WriteString(thisEvent.eventParm6);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
}
}
if (thisEvent.eventParm7 != null)
{
if (thisEvent.eventParm7.Length > 0)
{
myCheckedEvent.WriteStartElement("Parm7");
myCheckedEvent.WriteString(thisEvent.eventParm7);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
}
}
if (thisEvent.eventParm8 != null)
{
if (thisEvent.eventParm8.Length > 0)
{
myCheckedEvent.WriteStartElement("Parm8");
myCheckedEvent.WriteString(thisEvent.eventParm8);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
}
}
if (thisEvent.eventParm9 != null)
{
if (thisEvent.eventParm9.Length > 0)
{
myCheckedEvent.WriteStartElement("Parm9");
myCheckedEvent.WriteString(thisEvent.eventParm9);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
}
}
if (thisEvent.eventParm10 != null)
{
if (thisEvent.eventParm10.Length > 0)
{
myCheckedEvent.WriteStartElement("Parm10");
myCheckedEvent.WriteString(thisEvent.eventParm10);
myCheckedEvent.WriteEndElement();
myCheckedEvent.WriteWhitespace("\n");
}
}
myCheckedEvent.WriteEndElement(); // XTRMEvent
}
catch (Exception ex)
{
XLogger(1106, rc, string.Format("Caught Event Loader Exception; Folder={0}; UUID={1}; Message={2}", strPendingEventFolder, thisEvent.eventUUID, ex.Message));
}
}
myCheckedEvent.WriteEndElement(); // XTRMRoot
myCheckedEvent.Flush();
}
else
{
XLogger(1129, -1, string.Format("Event File Too Large; Folder={0}; File={1}; rc={2}", strPendingEventFolder, fileName, rc));
}
}
catch (Exception ex)
{
XLogger(1130, -1, string.Format("ParseConfig Exception; Folder={0}; File={1}; rc={2}", strPendingEventFolder, fileName, rc));
}
}
}
catch (Exception ex)
{
XLogger(1108, -1, string.Format("ProcessPendingEvents::Get Files Exception; Folder={0}; Message={1}", strPendingEventFolder, ex.Message));
}
return(rc);
}