public void FromXml(string configurationString)
{
XmlDocument config = new XmlDocument();
config.LoadXml(configurationString);
XmlElement root = config.DocumentElement;
Entries.Clear();
foreach (XmlElement queryNode in root.SelectNodes("directoryServices/query"))
{
DirectoryServicesQueryCollectorConfigEntry dirSrvsQryEntry = new DirectoryServicesQueryCollectorConfigEntry();
dirSrvsQryEntry.Name = queryNode.ReadXmlElementAttr("name", "");
dirSrvsQryEntry.DomainController = queryNode.ReadXmlElementAttr("domainController", "");
dirSrvsQryEntry.PropertiesToLoad = queryNode.ReadXmlElementAttr("propertiesToLoad", "sAMAccountName");
dirSrvsQryEntry.UseRowCountAsValue = queryNode.ReadXmlElementAttr("useRowCountAsValue", false);
dirSrvsQryEntry.MaxRowsToEvaluate = queryNode.ReadXmlElementAttr("maxRows", 1);
dirSrvsQryEntry.ReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(queryNode.ReadXmlElementAttr("returnCheckSequence", "gwe"));
XmlNode queryFilterNode = queryNode.SelectSingleNode("queryFilter");
dirSrvsQryEntry.QueryFilterText = queryFilterNode.InnerText;
XmlNode goodConditionNode = queryNode.SelectSingleNode("goodCondition");
dirSrvsQryEntry.GoodResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(goodConditionNode.ReadXmlElementAttr("resultMatchType", "match"));
dirSrvsQryEntry.GoodScriptText = goodConditionNode.InnerText;
XmlNode warningConditionNode = queryNode.SelectSingleNode("warningCondition");
dirSrvsQryEntry.WarningResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningConditionNode.ReadXmlElementAttr("resultMatchType", "match"));
dirSrvsQryEntry.WarningScriptText = warningConditionNode.InnerText;
XmlNode errorConditionNode = queryNode.SelectSingleNode("errorCondition");
dirSrvsQryEntry.ErrorResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorConditionNode.ReadXmlElementAttr("resultMatchType", "match"));
dirSrvsQryEntry.ErrorScriptText = errorConditionNode.InnerText;
Entries.Add(dirSrvsQryEntry);
}
}
private void cmdTest_Click(object sender, EventArgs e)
{
try
{
LinuxSSHCommandEntry testEntry = new LinuxSSHCommandEntry()
{
SSHConnection = sshConnectionDetails
};
testEntry.CommandString = txtCommandText.Text;
testEntry.ValueReturnCheckSequence = optEWG.Checked ? CollectorAgentReturnValueCheckSequence.EWG : CollectorAgentReturnValueCheckSequence.GWE;
testEntry.ValueReturnType = (SSHCommandValueReturnType)cboReturnType.SelectedIndex;
testEntry.SuccessMatchType = (CollectorAgentReturnValueCompareMatchType )cboSuccessMatchType.SelectedIndex;
testEntry.SuccessValueOrMacro = txtGoodValueOrMacro.Text;
testEntry.WarningMatchType = (CollectorAgentReturnValueCompareMatchType)cboWarningMatchType.SelectedIndex;
testEntry.WarningValueOrMacro = txtWarningValueOrMacro.Text;
testEntry.ErrorMatchType = (CollectorAgentReturnValueCompareMatchType)cboErrorMatchType.SelectedIndex;
testEntry.ErrorValueOrMacro = txtErrorValueOrMacro.Text;
string value = testEntry.ExecuteCommand();
CollectorState currentState = CollectorAgentReturnValueCompareEngine.GetState(testEntry.ValueReturnCheckSequence, testEntry.SuccessMatchType, testEntry.SuccessValueOrMacro,
testEntry.WarningMatchType, testEntry.WarningValueOrMacro, testEntry.ErrorMatchType, testEntry.ErrorValueOrMacro, value);
MessageBox.Show(string.Format("Returned state: {0}\r\nOutput: {1}", currentState, value), "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
public void FromXml(string configurationString)
{
XmlDocument config = new XmlDocument();
config.LoadXml(configurationString);
Entries.Clear();
XmlElement root = config.DocumentElement;
foreach (XmlElement powerShellScriptRunnerNode in root.SelectNodes("powerShellScripts/powerShellScriptRunner"))
{
PowerShellScriptRunnerEntry entry = new PowerShellScriptRunnerEntry();
entry.Name = powerShellScriptRunnerNode.ReadXmlElementAttr("name", "");
entry.ReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(powerShellScriptRunnerNode.ReadXmlElementAttr("returnCheckSequence", "gwe"));
XmlNode testScriptNode = powerShellScriptRunnerNode.SelectSingleNode("testScript");
entry.TestScript = testScriptNode.InnerText;
XmlNode goodScriptNode = powerShellScriptRunnerNode.SelectSingleNode("goodScript");
entry.GoodResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(goodScriptNode.ReadXmlElementAttr("resultMatchType", "match"));
entry.GoodScriptText = goodScriptNode.InnerText;
XmlNode warningScriptNode = powerShellScriptRunnerNode.SelectSingleNode("warningScript");
entry.WarningResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningScriptNode.ReadXmlElementAttr("resultMatchType", "match"));
entry.WarningScriptText = warningScriptNode.InnerText;
XmlNode errorScriptNode = powerShellScriptRunnerNode.SelectSingleNode("errorScript");
entry.ErrorResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorScriptNode.ReadXmlElementAttr("resultMatchType", "match"));
entry.ErrorScriptText = errorScriptNode.InnerText;
Entries.Add(entry);
}
}
public override MonitorState GetCurrentState()
{
string returnedData = "";
CollectorState agentState = CollectorState.NotAvailable;
try
{
returnedData = ExecuteCommand();
CurrentAgentValue = FormatUtils.FormatArrayToString(returnedData, "[null]");
agentState = CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence,
GoodResultMatchType, GoodValue,
WarningResultMatchType, WarningValue,
ErrorResultMatchType, ErrorValue,
CurrentAgentValue);
}
catch (Exception wsException)
{
agentState = CollectorState.Error;
returnedData = wsException.Message;
}
MonitorState currentState = new MonitorState()
{
ForAgent = Description,
State = agentState,
CurrentValue = returnedData == null ? "N/A" : returnedData,
CurrentValueUnit = OutputValueUnit
};
return(currentState);
}
public MonitorState GetCurrentState()
{
object wsData = null;
CollectorState agentState = CollectorState.NotAvailable;
try
{
wsData = GetValue();
CurrentAgentValue = FormatUtils.FormatArrayToString(wsData, "[null]");
agentState = CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence,
GoodResultMatchType, GoodValue,
WarningResultMatchType, WarningValue,
ErrorResultMatchType, ErrorValue,
CurrentAgentValue);
}
catch (Exception wsException)
{
agentState = CollectorState.Error;
wsData = wsException.Message;
}
MonitorState currentState = new MonitorState()
{
ForAgent = Description,
State = agentState,
CurrentValue = wsData == null ? "N/A" : wsData.ToString(),
CurrentValueUnit = OutputValueUnit
};
return(currentState);
}
public CollectorState GetState(string scriptResultText)
{
return(CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence,
GoodResultMatchType, GoodScriptText,
WarningResultMatchType, WarningScriptText,
ErrorResultMatchType, ErrorScriptText,
scriptResultText));
}
private void cmdTest_Click(object sender, EventArgs e)
{
try
{
string commandText = ApplyConfigVarsOnField(txtCommandText.Text);
string successText = ApplyConfigVarsOnField(txtSuccess.Text);
string warningText = ApplyConfigVarsOnField(txtWarning.Text);
string errorText = ApplyConfigVarsOnField(txtError.Text);
string connectionString = ApplyConfigVarsOnField(sshConnectionDetails.ConnectionString);
SSHConnectionDetails sshConnection;
if (connectionString.Length > 0)
{
sshConnection = SSHConnectionDetails.FromConnectionString(connectionString);
}
else
{
sshConnection = sshConnectionDetails.Clone();
sshConnection.ComputerName = ApplyConfigVarsOnField(sshConnection.ComputerName);
sshConnection.UserName = ApplyConfigVarsOnField(sshConnection.UserName);
sshConnection.Password = ApplyConfigVarsOnField(sshConnection.Password);
sshConnection.PrivateKeyFile = ApplyConfigVarsOnField(sshConnection.PrivateKeyFile);
sshConnection.PassPhrase = ApplyConfigVarsOnField(sshConnection.PassPhrase);
sshConnection.ConnectionName = ApplyConfigVarsOnField(sshConnection.ConnectionName);
}
SSHCommandCollectorConfigEntry testEntry = new SSHCommandCollectorConfigEntry()
{
SSHConnection = sshConnection
};
testEntry.CommandString = commandText;
testEntry.ValueReturnType = (SSHCommandValueReturnType)cboReturnType.SelectedIndex;
testEntry.ReturnCheckSequence = (CollectorAgentReturnValueCheckSequence)cboReturnCheckSequence.SelectedIndex;
testEntry.GoodResultMatchType = (CollectorAgentReturnValueCompareMatchType)cboSuccessMatchType.SelectedIndex;
testEntry.GoodValue = successText;
testEntry.WarningResultMatchType = (CollectorAgentReturnValueCompareMatchType)cboWarningMatchType.SelectedIndex;
testEntry.WarningValue = warningText;
testEntry.ErrorResultMatchType = (CollectorAgentReturnValueCompareMatchType)cboErrorMatchType.SelectedIndex;
testEntry.ErrorValue = errorText;
testEntry.OutputValueUnit = cboOutputValueUnit.Text;
string value = testEntry.ExecuteCommand();
CollectorState currentState = CollectorAgentReturnValueCompareEngine.GetState(testEntry.ReturnCheckSequence,
testEntry.GoodResultMatchType, testEntry.GoodValue,
testEntry.WarningResultMatchType, testEntry.WarningValue,
testEntry.ErrorResultMatchType, testEntry.ErrorValue, value);
MessageBox.Show(string.Format("Returned state: {0}\r\nOutput: {1}", currentState, value), "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
public MonitorState GetCurrentState()
{
MonitorState currentState = new MonitorState()
{
ForAgent = Description
};
object wsData = null;
CollectorState agentState = CollectorState.NotAvailable;
try
{
wsData = RunMethod();
if (ValueExpectedReturnType == WebServiceValueExpectedReturnTypeEnum.CheckAvailabilityOnly)
{
agentState = CollectorState.Good;
}
else
{
FormatCurrentAgentValue(wsData);
agentState = CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence,
GoodResultMatchType, GoodScriptText,
WarningResultMatchType, WarningScriptText,
ErrorResultMatchType, ErrorScriptText,
CurrentAgentValue);
}
}
catch (Exception wsException)
{
agentState = CollectorState.Error;
if (wsException.Message.Contains("Method") && wsException.Message.Contains("not found or parameters invalid!"))
{
wsData = "Invalid Method/Parameters!";
}
else if (wsException.Message.Contains("Object reference not set to an instance of an object"))
{
wsData = "Object instance not found!";
}
else if (wsException.Message.Contains("There was an error downloading"))
{
wsData = "WS down/Invalid URL!";
}
else
{
wsData = "WS Error";
}
currentState.RawDetails = wsException.Message;
}
currentState.State = agentState;
currentState.CurrentValue = CurrentAgentValue != null ? CurrentAgentValue : wsData == null ? "N/A" : wsData.ToString();
return(currentState);
}
public MonitorState GetCurrentState()
{
object value = RunQuery();
string unitName = OutputValueUnit;
if (UseRowCountAsValue && OutputValueUnit.Length == 0)
{
unitName = "row(s)";
}
MonitorState currentState = new MonitorState()
{
State = CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence, GoodResultMatchType, GoodValue,
WarningResultMatchType, WarningValue, ErrorResultMatchType, ErrorValue, value),
ForAgent = Name,
CurrentValue = value,
CurrentValueUnit = unitName
};
//object value = null;
//if (!ReturnValueIsInt)
//{
// value = RunQueryWithSingleResult();
//}
//else
//{
// if (UseRowCountAsValue)
// {
// value = RunQueryWithCountResult();
// }
// else
// {
// value = RunQueryWithSingleResult();
// }
//}
//CurrentAgentValue = value == null ? "[null]" : value;
//MonitorState currentState = new MonitorState()
//{
// ForAgent = Description,
// CurrentValue = value == null ? "[null]" : value,
// CurrentValueUnit = OutputValueUnit,
// State = GetState(value)
//};
if (currentState.State == CollectorState.Error)
{
currentState.RawDetails = string.Format("(Trigger '{0}')", ErrorValue);
}
else if (currentState.State == CollectorState.Warning)
{
currentState.RawDetails = string.Format("(Trigger '{0}')", WarningValue);
}
return(currentState);
}
public void FromXml(string configurationString)
{
XmlDocument config = new XmlDocument();
config.LoadXml(configurationString);
Entries.Clear();
XmlElement root = config.DocumentElement;
foreach (XmlElement queryNode in root.SelectNodes("queries/query"))
{
SqlQueryCollectorEntry queryEntry = new SqlQueryCollectorEntry();
queryEntry.Name = queryNode.ReadXmlElementAttr("name", "");
queryEntry.DataSourceType = queryNode.ReadXmlElementAttr("dataSourceType", "SqlServer").ToLower() == "oledb" ? DataSourceType.OLEDB : DataSourceType.SqlServer;
queryEntry.ConnectionString = queryNode.ReadXmlElementAttr("connStr", "");
queryEntry.ProviderName = queryNode.ReadXmlElementAttr("provider", "");
queryEntry.FileName = queryNode.ReadXmlElementAttr("fileName", "");
queryEntry.Server = queryNode.ReadXmlElementAttr("server", "");
queryEntry.Database = queryNode.ReadXmlElementAttr("database", "");
queryEntry.IntegratedSecurity = bool.Parse(queryNode.ReadXmlElementAttr("integratedSec", "True"));
queryEntry.UserName = queryNode.ReadXmlElementAttr("userName", "");
queryEntry.Password = queryNode.ReadXmlElementAttr("password", "");
queryEntry.CmndTimeOut = int.Parse(queryNode.ReadXmlElementAttr("cmndTimeOut", "60"));
queryEntry.UsePersistentConnection = bool.Parse(queryNode.ReadXmlElementAttr("usePersistentConnection", "False"));
queryEntry.ApplicationName = queryNode.ReadXmlElementAttr("applicationName", "QuickMon");
XmlNode alertTriggersNode = queryNode.SelectSingleNode("alertTriggers");
queryEntry.ValueReturnType = DataBaseQueryValueReturnTypeConverter.FromString(alertTriggersNode.ReadXmlElementAttr("valueReturnType", "RawValue"));
queryEntry.ValueReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(alertTriggersNode.ReadXmlElementAttr("checkSequence", "EWG"));
XmlNode successNode = alertTriggersNode.SelectSingleNode("success");
queryEntry.SuccessMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(successNode.ReadXmlElementAttr("matchType", "Match"));
queryEntry.SuccessValueOrMacro = successNode.ReadXmlElementAttr("value", "[any]");
XmlNode warningNode = alertTriggersNode.SelectSingleNode("warning");
queryEntry.WarningMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningNode.ReadXmlElementAttr("matchType", "Match"));
queryEntry.WarningValueOrMacro = warningNode.ReadXmlElementAttr("value", "0");
XmlNode errorNode = alertTriggersNode.SelectSingleNode("error");
queryEntry.ErrorMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorNode.ReadXmlElementAttr("matchType", "Match"));
queryEntry.ErrorValueOrMacro = errorNode.ReadXmlElementAttr("value", "[null]");
XmlNode stateQueryNode = queryNode.SelectSingleNode("stateQuery");
queryEntry.UseSPForStateQuery = stateQueryNode.ReadXmlElementAttr("useSP", false);
queryEntry.StateQuery = stateQueryNode.InnerText;
XmlNode detailQueryNode = queryNode.SelectSingleNode("detailQuery");
queryEntry.UseSPForDetailQuery = detailQueryNode.ReadXmlElementAttr("useSP", false);
queryEntry.DetailQuery = detailQueryNode.InnerText;
Entries.Add(queryEntry);
}
}
public void FromXml(string configurationString)
{
if (configurationString == null || configurationString.Length == 0)
{
return;
}
XmlDocument config = new XmlDocument();
config.LoadXml(configurationString);
XmlElement root = config.DocumentElement;
Entries.Clear();
foreach (XmlElement cmndNode in root.SelectNodes("linux/sshCommand"))
{
LinuxSSHCommandEntry entry = new LinuxSSHCommandEntry();
entry.SSHConnection = SSHConnectionDetails.FromXmlElement(cmndNode);
//entry.SSHConnection.SSHSecurityOption = SSHSecurityOptionTypeConverter.FromString(cmndNode.ReadXmlElementAttr("sshSecOpt", "password"));
//entry.SSHConnection.ComputerName = cmndNode.ReadXmlElementAttr("machine", ".");
//entry.SSHConnection.SSHPort = cmndNode.ReadXmlElementAttr("sshPort", 22);
//entry.SSHConnection.UserName = cmndNode.ReadXmlElementAttr("userName", "");
//entry.SSHConnection.Password = cmndNode.ReadXmlElementAttr("password", "");
//entry.SSHConnection.PrivateKeyFile = cmndNode.ReadXmlElementAttr("privateKeyFile", "");
//entry.SSHConnection.PassPhrase = cmndNode.ReadXmlElementAttr("passPhrase", "");
//entry.SSHConnection.Persistent = cmndNode.ReadXmlElementAttr("persistent", false);
entry.Name = cmndNode.ReadXmlElementAttr("name", "");
XmlNode commandStringNode = cmndNode.SelectSingleNode("commandString");
entry.CommandString = cmndNode.InnerText;
XmlNode alertTriggersNode = cmndNode.SelectSingleNode("alertTriggers");
entry.ValueReturnType = SSHCommandValueReturnTypeConverter.FromString(alertTriggersNode.ReadXmlElementAttr("valueReturnType", "RawValue"));
entry.ValueReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(alertTriggersNode.ReadXmlElementAttr("checkSequence", "EWG"));
XmlNode successNode = alertTriggersNode.SelectSingleNode("success");
entry.SuccessMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(successNode.ReadXmlElementAttr("matchType", "Match"));
entry.SuccessValueOrMacro = successNode.ReadXmlElementAttr("value", "[any]");
XmlNode warningNode = alertTriggersNode.SelectSingleNode("warning");
entry.WarningMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningNode.ReadXmlElementAttr("matchType", "Match"));
entry.WarningValueOrMacro = warningNode.ReadXmlElementAttr("value", "0");
XmlNode errorNode = alertTriggersNode.SelectSingleNode("error");
entry.ErrorMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorNode.ReadXmlElementAttr("matchType", "Match"));
entry.ErrorValueOrMacro = errorNode.ReadXmlElementAttr("value", "[null]");
Entries.Add(entry);
}
}
public MonitorState GetCurrentState()
{
MonitorState currentState = new MonitorState()
{
ForAgent = Description
};
try
{
string scriptResultText = RunScript();
if (scriptResultText.Contains("System.Management.Automation.CommandNotFoundException"))
{
currentState.State = CollectorState.Error;
currentState.CurrentValue = "Bad command(s)";
currentState.CurrentValueUnit = "";
CurrentAgentValue = "Bad command(s)";
currentState.RawDetails = scriptResultText;
}
else if (scriptResultText.Contains("The remote server returned an error: (401) Unauthorized"))
{
currentState.State = CollectorState.Error;
currentState.CurrentValue = "Unauthorized";
currentState.CurrentValueUnit = "";
CurrentAgentValue = "Unauthorized";
currentState.RawDetails = scriptResultText;
}
else
{
CurrentAgentValue = scriptResultText;
currentState.CurrentValue = scriptResultText;
currentState.CurrentValueUnit = OutputValueUnit;
CollectorState currentScriptState = CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence,
GoodResultMatchType, GoodScriptText,
WarningResultMatchType, WarningScriptText,
ErrorResultMatchType, ErrorScriptText,
scriptResultText);
currentState.State = currentScriptState;
}
}
catch (Exception ex)
{
currentState.State = CollectorState.Error;
currentState.CurrentValue = "Unknown error";
currentState.CurrentValueUnit = "";
currentState.RawDetails = ex.Message;
}
return(currentState);
}
public MonitorState GetCurrentState()
{
object value = GetStateQueryValue();
string unitName = ValueReturnType == DataBaseQueryValueReturnType.RowCount ? "row(s)" : ValueReturnType == DataBaseQueryValueReturnType.QueryTime ? "ms" : OutputValueUnit;
MonitorState currentState = new MonitorState()
{
State = CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence, GoodResultMatchType, GoodValue,
WarningResultMatchType, WarningValue, ErrorResultMatchType, ErrorValue, value),
ForAgent = Name,
CurrentValue = value,
CurrentValueUnit = unitName
};
return(currentState);
}
public void FromXml(string configurationString)
{
XmlDocument config = new XmlDocument();
config.LoadXml(configurationString);
Entries.Clear();
XmlElement root = config.DocumentElement;
//version 5 config
foreach (XmlElement carvceEntryNode in root.SelectNodes("carvcesEntries/carvceEntry"))
{
XmlNode dataSourceNode = carvceEntryNode.SelectSingleNode("dataSource");
SSHCommandCollectorConfigEntry sshEntry = new SSHCommandCollectorConfigEntry();
sshEntry.Name = dataSourceNode.ReadXmlElementAttr("name", "");
sshEntry.PrimaryUIValue = dataSourceNode.ReadXmlElementAttr("primaryUIValue", false);
sshEntry.OutputValueUnit = dataSourceNode.ReadXmlElementAttr("outputValueUnit", "");
sshEntry.SSHConnection = SSHConnectionDetails.FromXmlElement((XmlElement)dataSourceNode);
XmlNode stateQueryNode = dataSourceNode.SelectSingleNode("stateQuery");
sshEntry.ValueReturnType = SSHCommandValueReturnTypeConverter.FromString(stateQueryNode.ReadXmlElementAttr("valueReturnType", "RawValue"));
sshEntry.CommandString = stateQueryNode.InnerText;
XmlNode testConditionsNode = carvceEntryNode.SelectSingleNode("testConditions");
if (testConditionsNode != null)
{
sshEntry.ReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(testConditionsNode.ReadXmlElementAttr("testSequence", "gwe"));
XmlNode goodScriptNode = testConditionsNode.SelectSingleNode("success");
sshEntry.GoodResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(goodScriptNode.ReadXmlElementAttr("testType", "match"));
sshEntry.GoodValue = goodScriptNode.InnerText;
XmlNode warningScriptNode = testConditionsNode.SelectSingleNode("warning");
sshEntry.WarningResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningScriptNode.ReadXmlElementAttr("testType", "match"));
sshEntry.WarningValue = warningScriptNode.InnerText;
XmlNode errorScriptNode = testConditionsNode.SelectSingleNode("error");
sshEntry.ErrorResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorScriptNode.ReadXmlElementAttr("testType", "match"));
sshEntry.ErrorValue = errorScriptNode.InnerText;
}
else
{
sshEntry.ReturnCheckSequence = CollectorAgentReturnValueCheckSequence.GWE;
}
Entries.Add(sshEntry);
}
}
private void DirectoryServicesQueryCollectorEditEntry_Load(object sender, EventArgs e)
{
if (SelectedEntry == null)
{
SelectedEntry = new DirectoryServicesQueryCollectorConfigEntry();
}
DirectoryServicesQueryCollectorConfigEntry selectedEntry = (DirectoryServicesQueryCollectorConfigEntry)SelectedEntry;
#region Load Match types
cboSuccessMatchType.Items.Clear();
cboSuccessMatchType.Items.AddRange(CollectorAgentReturnValueCompareEngine.ReturnValueCompareMatchTypesToList().ToArray());
if (cboSuccessMatchType.Items.Count > 0)
{
cboSuccessMatchType.SelectedIndex = 0;
}
cboWarningMatchType.Items.Clear();
cboWarningMatchType.Items.AddRange(CollectorAgentReturnValueCompareEngine.ReturnValueCompareMatchTypesToList().ToArray());
if (cboWarningMatchType.Items.Count > 0)
{
cboWarningMatchType.SelectedIndex = 0;
}
cboErrorMatchType.Items.Clear();
cboErrorMatchType.Items.AddRange(CollectorAgentReturnValueCompareEngine.ReturnValueCompareMatchTypesToList().ToArray());
if (cboErrorMatchType.Items.Count > 0)
{
cboErrorMatchType.SelectedIndex = 0;
}
#endregion
if (selectedEntry != null)
{
txtName.Text = selectedEntry.Name;
txtDomainController.Text = selectedEntry.DomainController;
txtQueryText.Text = selectedEntry.QueryFilterText;
txtPropertiestToLoad.Text = selectedEntry.PropertiesToLoad;
optEWG.Checked = selectedEntry.ReturnCheckSequence == CollectorAgentReturnValueCheckSequence.EWG;
chkUseRowCount.Checked = selectedEntry.UseRowCountAsValue;
maxRowsNumericUpDown.Value = selectedEntry.MaxRowsToEvaluate;
txtSuccess.Text = selectedEntry.GoodScriptText;
cboSuccessMatchType.SelectedIndex = (int)selectedEntry.GoodResultMatchType;
txtWarning.Text = selectedEntry.WarningScriptText;
cboWarningMatchType.SelectedIndex = (int)selectedEntry.WarningResultMatchType;
txtError.Text = selectedEntry.ErrorScriptText;
cboErrorMatchType.SelectedIndex = (int)selectedEntry.ErrorResultMatchType;
}
}
public MonitorState GetCurrentState()
{
MonitorState currentState = new MonitorState()
{
ForAgent = Name
};
try
{
object value = RunQuery();
string unitName = OutputValueUnit;
if (UseRowCountAsValue && OutputValueUnit.Length == 0)
{
unitName = "row(s)";
}
currentState.State = CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence, GoodResultMatchType, GoodValue,
WarningResultMatchType, WarningValue, ErrorResultMatchType, ErrorValue, value);
currentState.CurrentValue = value;
currentState.CurrentValueUnit = unitName;
if (currentState.State == CollectorState.Error)
{
currentState.RawDetails = string.Format("(Trigger '{0}')", ErrorValue);
}
else if (currentState.State == CollectorState.Warning)
{
currentState.RawDetails = string.Format("(Trigger '{0}')", WarningValue);
}
}
catch (Exception ex)
{
currentState.State = CollectorState.Error;
currentState.RawDetails = ex.Message;
if (ex.Message.Contains("Invalid class"))
{
currentState.CurrentValue = "Invalid class";
}
else if (ex.Message.Contains("Invalid query"))
{
currentState.CurrentValue = "Invalid query";
}
}
return(currentState);
}
public MonitorState GetCurrentState()
{
string scriptResultText = RunScript();
CurrentAgentValue = scriptResultText;
MonitorState currentState = new MonitorState()
{
ForAgent = Description,
CurrentValue = scriptResultText
};
CollectorState currentScriptState = CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence,
GoodResultMatchType, GoodScriptText,
WarningResultMatchType, WarningScriptText,
ErrorResultMatchType, ErrorScriptText,
scriptResultText);
currentState.State = currentScriptState;
return(currentState);
}
private void PowerShellScriptRunnerCollectorEditEntry_Load(object sender, EventArgs e)
{
if (SelectedEntry == null)
{
SelectedEntry = new PowerShellScriptRunnerEntry();
}
PowerShellScriptRunnerEntry selectedEntry = (PowerShellScriptRunnerEntry)SelectedEntry;
#region Load Match types
cboSuccessMatchType.Items.Clear();
cboSuccessMatchType.Items.AddRange(CollectorAgentReturnValueCompareEngine.ReturnValueCompareMatchTypesToList().ToArray());
if (cboSuccessMatchType.Items.Count > 0)
{
cboSuccessMatchType.SelectedIndex = 0;
}
cboWarningMatchType.Items.Clear();
cboWarningMatchType.Items.AddRange(CollectorAgentReturnValueCompareEngine.ReturnValueCompareMatchTypesToList().ToArray());
if (cboWarningMatchType.Items.Count > 0)
{
cboWarningMatchType.SelectedIndex = 0;
}
cboErrorMatchType.Items.Clear();
cboErrorMatchType.Items.AddRange(CollectorAgentReturnValueCompareEngine.ReturnValueCompareMatchTypesToList().ToArray());
if (cboErrorMatchType.Items.Count > 0)
{
cboErrorMatchType.SelectedIndex = 0;
}
#endregion
txtName.Text = selectedEntry.Name;
cboOutputValueUnit.Text = selectedEntry.OutputValueUnit;
cboReturnCheckSequence.SelectedIndex = (int)selectedEntry.ReturnCheckSequence;
txtScript.Text = selectedEntry.TestScript;
txtSuccess.Text = selectedEntry.GoodScriptText;
cboSuccessMatchType.SelectedIndex = (int)selectedEntry.GoodResultMatchType;
txtWarning.Text = selectedEntry.WarningScriptText;
cboWarningMatchType.SelectedIndex = (int)selectedEntry.WarningResultMatchType;
txtError.Text = selectedEntry.ErrorScriptText;
cboErrorMatchType.SelectedIndex = (int)selectedEntry.ErrorResultMatchType;
}
public MonitorState GetCurrentState()
{
object wsData = null;
CollectorState agentState = CollectorState.NotAvailable;
try
{
wsData = RunMethod();
if (ValueExpectedReturnType == WebServiceValueExpectedReturnTypeEnum.CheckAvailabilityOnly)
{
agentState = CollectorState.Good;
}
else
{
FormatCurrentAgentValue(wsData);
agentState = CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence,
GoodResultMatchType, GoodScriptText,
WarningResultMatchType, WarningScriptText,
ErrorResultMatchType, ErrorScriptText,
CurrentAgentValue);
}
}
catch (Exception wsException)
{
agentState = CollectorState.Error;
wsData = wsException.Message;
}
MonitorState currentState = new MonitorState()
{
ForAgent = Description,
State = agentState,
CurrentValue = wsData == null ? "N/A" : wsData.ToString()
};
return(currentState);
}
public void FromXml(string configurationString)
{
XmlDocument config = new XmlDocument();
config.LoadXml(configurationString);
Entries.Clear();
XmlElement root = config.DocumentElement;
//Old format
foreach (XmlElement powerShellScriptRunnerNode in root.SelectNodes("powerShellScripts/powerShellScriptRunner"))
{
PowerShellScriptRunnerEntry entry = new PowerShellScriptRunnerEntry();
entry.Name = powerShellScriptRunnerNode.ReadXmlElementAttr("name", "");
entry.ReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(powerShellScriptRunnerNode.ReadXmlElementAttr("returnCheckSequence", "gwe"));
XmlNode testScriptNode = powerShellScriptRunnerNode.SelectSingleNode("testScript");
entry.TestScript = testScriptNode.InnerText;
XmlNode goodScriptNode = powerShellScriptRunnerNode.SelectSingleNode("goodScript");
entry.GoodResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(goodScriptNode.ReadXmlElementAttr("resultMatchType", "match"));
entry.GoodScriptText = goodScriptNode.InnerText;
XmlNode warningScriptNode = powerShellScriptRunnerNode.SelectSingleNode("warningScript");
entry.WarningResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningScriptNode.ReadXmlElementAttr("resultMatchType", "match"));
entry.WarningScriptText = warningScriptNode.InnerText;
XmlNode errorScriptNode = powerShellScriptRunnerNode.SelectSingleNode("errorScript");
entry.ErrorResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorScriptNode.ReadXmlElementAttr("resultMatchType", "match"));
entry.ErrorScriptText = errorScriptNode.InnerText;
Entries.Add(entry);
}
//New format
foreach (XmlElement carvceEntryNode in root.SelectNodes("carvcesEntries/carvceEntry"))
{
PowerShellScriptRunnerEntry entry = new PowerShellScriptRunnerEntry();
entry.Name = carvceEntryNode.ReadXmlElementAttr("name", "");
entry.PrimaryUIValue = carvceEntryNode.ReadXmlElementAttr("primaryUIValue", false);
entry.OutputValueUnit = carvceEntryNode.ReadXmlElementAttr("outputValueUnit", "");
XmlNode testScriptNode = carvceEntryNode.SelectSingleNode("dataSource");
entry.TestScript = testScriptNode.InnerText;
XmlNode testConditionsNode = carvceEntryNode.SelectSingleNode("testConditions");
entry.ReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(testConditionsNode.ReadXmlElementAttr("testSequence", "gwe"));
XmlNode goodScriptNode = testConditionsNode.SelectSingleNode("success");
entry.GoodResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(goodScriptNode.ReadXmlElementAttr("testType", "match"));
entry.GoodScriptText = goodScriptNode.InnerText;
XmlNode warningScriptNode = testConditionsNode.SelectSingleNode("warning");
entry.WarningResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningScriptNode.ReadXmlElementAttr("testType", "match"));
entry.WarningScriptText = warningScriptNode.InnerText;
XmlNode errorScriptNode = testConditionsNode.SelectSingleNode("error");
entry.ErrorResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorScriptNode.ReadXmlElementAttr("testType", "match"));
entry.ErrorScriptText = errorScriptNode.InnerText;
Entries.Add(entry);
}
}
public void FromXml(string configurationString)
{
XmlDocument config = new XmlDocument();
config.LoadXml(configurationString);
Entries.Clear();
XmlElement root = config.DocumentElement;
//version 4 type config
foreach (XmlElement wmiQueryNode in root.SelectNodes("wmiQueries/wmiQuery"))
{
WMIQueryCollectorConfigEntry entry = new WMIQueryCollectorConfigEntry();
entry.Name = wmiQueryNode.ReadXmlElementAttr("name", entry.Machinename);
entry.Namespace = wmiQueryNode.ReadXmlElementAttr("namespace", "root\\CIMV2");
entry.Machinename = wmiQueryNode.ReadXmlElementAttr("machineName", ".");
entry.PrimaryUIValue = wmiQueryNode.ReadXmlElementAttr("primaryUIValue", false);
entry.OutputValueUnit = wmiQueryNode.ReadXmlElementAttr("outputValueUnit", "");
XmlNode stateQueryNode = wmiQueryNode.SelectSingleNode("stateQuery");
entry.StateQuery = stateQueryNode.ReadXmlElementAttr("syntax", "");
//entry.ReturnValueIsInt = bool.Parse(stateQueryNode.ReadXmlElementAttr("returnValueIsInt", "True"));
//entry.ReturnValueInverted = bool.Parse(stateQueryNode.ReadXmlElementAttr("returnValueInverted", "False"));
if (bool.Parse(stateQueryNode.ReadXmlElementAttr("returnValueInverted", "False")))
{
entry.ReturnCheckSequence = CollectorAgentReturnValueCheckSequence.EWG;
}
else
{
entry.ReturnCheckSequence = CollectorAgentReturnValueCheckSequence.GWE;
}
entry.GoodResultMatchType = CollectorAgentReturnValueCompareMatchType.Match;
entry.WarningResultMatchType = CollectorAgentReturnValueCompareMatchType.Match;
entry.ErrorResultMatchType = CollectorAgentReturnValueCompareMatchType.Match;
entry.WarningValue = stateQueryNode.ReadXmlElementAttr("warningValue", "0");
entry.ErrorValue = stateQueryNode.ReadXmlElementAttr("errorValue", "0");
entry.GoodValue = stateQueryNode.ReadXmlElementAttr("successValue", "0");
entry.UseRowCountAsValue = bool.Parse(stateQueryNode.ReadXmlElementAttr("useRowCountAsValue", "True"));
XmlNode detailQueryNode = wmiQueryNode.SelectSingleNode("detailQuery");
entry.DetailQuery = detailQueryNode.ReadXmlElementAttr("syntax", "");
string columns = detailQueryNode.ReadXmlElementAttr("columnNames", "");
entry.ColumnNames = new List <string>();
if (columns.Length > 0 && columns.IndexOf(',') > -1)
{
entry.ColumnNames = columns.ToListFromCSVString();
}
else if (columns.Length > 0)
{
entry.ColumnNames.Add(columns);
}
Entries.Add(entry);
}
//version 5 type config
foreach (XmlElement carvceEntryNode in root.SelectNodes("carvcesEntries/carvceEntry"))
{
XmlNode dataSourceNode = carvceEntryNode.SelectSingleNode("dataSource");
WMIQueryCollectorConfigEntry entry = new WMIQueryCollectorConfigEntry();
entry.Name = dataSourceNode.ReadXmlElementAttr("name", "");
entry.Namespace = dataSourceNode.ReadXmlElementAttr("namespace", "root\\CIMV2");
entry.Machinename = dataSourceNode.ReadXmlElementAttr("machineName", ".");
entry.PrimaryUIValue = dataSourceNode.ReadXmlElementAttr("primaryUIValue", false);
entry.OutputValueUnit = dataSourceNode.ReadXmlElementAttr("outputValueUnit", "");
XmlNode stateQueryNode = dataSourceNode.SelectSingleNode("stateQuery");
//entry.ReturnValueIsInt = bool.Parse(stateQueryNode.ReadXmlElementAttr("returnValueIsInt", "False"));
entry.UseRowCountAsValue = bool.Parse(stateQueryNode.ReadXmlElementAttr("useRowCountAsValue", "False"));
entry.StateQuery = stateQueryNode.InnerText;
XmlNode detailQueryNode = dataSourceNode.SelectSingleNode("detailQuery");
string columns = detailQueryNode.ReadXmlElementAttr("columnNames", "");
entry.ColumnNames = new List <string>();
if (columns.Length > 0 && columns.IndexOf(',') > -1)
{
entry.ColumnNames = columns.ToListFromCSVString();
}
else if (columns.Length > 0)
{
entry.ColumnNames.Add(columns);
}
entry.DetailQuery = detailQueryNode.InnerText;
XmlNode testConditionsNode = carvceEntryNode.SelectSingleNode("testConditions");
if (testConditionsNode != null)
{
entry.ReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(testConditionsNode.ReadXmlElementAttr("testSequence", "gwe"));
XmlNode goodScriptNode = testConditionsNode.SelectSingleNode("success");
entry.GoodResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(goodScriptNode.ReadXmlElementAttr("testType", "match"));
entry.GoodValue = goodScriptNode.InnerText;
XmlNode warningScriptNode = testConditionsNode.SelectSingleNode("warning");
entry.WarningResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningScriptNode.ReadXmlElementAttr("testType", "match"));
entry.WarningValue = warningScriptNode.InnerText;
XmlNode errorScriptNode = testConditionsNode.SelectSingleNode("error");
entry.ErrorResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorScriptNode.ReadXmlElementAttr("testType", "match"));
entry.ErrorValue = errorScriptNode.InnerText;
}
else
{
entry.ReturnCheckSequence = CollectorAgentReturnValueCheckSequence.GWE;
}
Entries.Add(entry);
}
}
public void FromXml(string configurationString)
{
XmlDocument config = new XmlDocument();
config.LoadXml(configurationString);
Entries.Clear();
XmlElement root = config.DocumentElement;
//Version 4 config
foreach (XmlElement queryNode in root.SelectNodes("queries/query"))
{
SqlQueryCollectorEntry queryEntry = new SqlQueryCollectorEntry();
queryEntry.Name = queryNode.ReadXmlElementAttr("name", "");
queryEntry.DataSourceType = queryNode.ReadXmlElementAttr("dataSourceType", "SqlServer").ToLower() == "oledb" ? DataSourceType.OLEDB : DataSourceType.SqlServer;
queryEntry.ConnectionString = queryNode.ReadXmlElementAttr("connStr", "");
queryEntry.ProviderName = queryNode.ReadXmlElementAttr("provider", "");
queryEntry.FileName = queryNode.ReadXmlElementAttr("fileName", "");
queryEntry.Server = queryNode.ReadXmlElementAttr("server", "");
queryEntry.Database = queryNode.ReadXmlElementAttr("database", "");
queryEntry.IntegratedSecurity = bool.Parse(queryNode.ReadXmlElementAttr("integratedSec", "True"));
queryEntry.UserName = queryNode.ReadXmlElementAttr("userName", "");
queryEntry.Password = queryNode.ReadXmlElementAttr("password", "");
queryEntry.CmndTimeOut = int.Parse(queryNode.ReadXmlElementAttr("cmndTimeOut", "60"));
queryEntry.UsePersistentConnection = bool.Parse(queryNode.ReadXmlElementAttr("usePersistentConnection", "False"));
queryEntry.ApplicationName = queryNode.ReadXmlElementAttr("applicationName", "QuickMon");
queryEntry.PrimaryUIValue = queryNode.ReadXmlElementAttr("primaryUIValue", false);
XmlNode alertTriggersNode = queryNode.SelectSingleNode("alertTriggers");
queryEntry.ValueReturnType = DataBaseQueryValueReturnTypeConverter.FromString(alertTriggersNode.ReadXmlElementAttr("valueReturnType", "RawValue"));
queryEntry.ReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(alertTriggersNode.ReadXmlElementAttr("checkSequence", "EWG"));
XmlNode successNode = alertTriggersNode.SelectSingleNode("success");
queryEntry.GoodResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(successNode.ReadXmlElementAttr("matchType", "Match"));
queryEntry.GoodValue = successNode.ReadXmlElementAttr("value", "[any]");
XmlNode warningNode = alertTriggersNode.SelectSingleNode("warning");
queryEntry.WarningResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningNode.ReadXmlElementAttr("matchType", "Match"));
queryEntry.WarningValue = warningNode.ReadXmlElementAttr("value", "0");
XmlNode errorNode = alertTriggersNode.SelectSingleNode("error");
queryEntry.ErrorResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorNode.ReadXmlElementAttr("matchType", "Match"));
queryEntry.ErrorValue = errorNode.ReadXmlElementAttr("value", "[null]");
XmlNode stateQueryNode = queryNode.SelectSingleNode("stateQuery");
queryEntry.UseSPForStateQuery = stateQueryNode.ReadXmlElementAttr("useSP", false);
queryEntry.StateQuery = stateQueryNode.InnerText;
//XmlNode detailQueryNode = queryNode.SelectSingleNode("detailQuery");
//queryEntry.UseSPForDetailQuery = detailQueryNode.ReadXmlElementAttr("useSP", false);
//queryEntry.DetailQuery = detailQueryNode.InnerText;
Entries.Add(queryEntry);
}
//version 5 config
foreach (XmlElement carvceEntryNode in root.SelectNodes("carvcesEntries/carvceEntry"))
{
XmlNode dataSourceNode = carvceEntryNode.SelectSingleNode("dataSource");
SqlQueryCollectorEntry queryEntry = new SqlQueryCollectorEntry();
queryEntry.Name = dataSourceNode.ReadXmlElementAttr("name", "");
queryEntry.DataSourceType = dataSourceNode.ReadXmlElementAttr("dataSourceType", "SqlServer").ToLower() == "oledb" ? DataSourceType.OLEDB : DataSourceType.SqlServer;
queryEntry.ConnectionString = dataSourceNode.ReadXmlElementAttr("connStr", "");
queryEntry.ProviderName = dataSourceNode.ReadXmlElementAttr("provider", "");
queryEntry.FileName = dataSourceNode.ReadXmlElementAttr("fileName", "");
queryEntry.Server = dataSourceNode.ReadXmlElementAttr("server", "");
queryEntry.Database = dataSourceNode.ReadXmlElementAttr("database", "");
queryEntry.IntegratedSecurity = bool.Parse(dataSourceNode.ReadXmlElementAttr("integratedSec", "True"));
queryEntry.UserName = dataSourceNode.ReadXmlElementAttr("userName", "");
queryEntry.Password = dataSourceNode.ReadXmlElementAttr("password", "");
queryEntry.CmndTimeOut = int.Parse(dataSourceNode.ReadXmlElementAttr("cmndTimeOut", "60"));
queryEntry.UsePersistentConnection = bool.Parse(dataSourceNode.ReadXmlElementAttr("usePersistentConnection", "False"));
queryEntry.ApplicationName = dataSourceNode.ReadXmlElementAttr("applicationName", "QuickMon");
queryEntry.PrimaryUIValue = dataSourceNode.ReadXmlElementAttr("primaryUIValue", false);
queryEntry.OutputValueUnit = dataSourceNode.ReadXmlElementAttr("outputValueUnit", "");
XmlNode stateQueryNode = dataSourceNode.SelectSingleNode("stateQuery");
queryEntry.UseSPForStateQuery = stateQueryNode.ReadXmlElementAttr("useSP", false);
queryEntry.StateQuery = stateQueryNode.InnerText;
//XmlNode detailQueryNode = dataSourceNode.SelectSingleNode("detailQuery");
//queryEntry.UseSPForDetailQuery = detailQueryNode.ReadXmlElementAttr("useSP", false);
//queryEntry.DetailQuery = detailQueryNode.InnerText;
XmlNode testConditionsNode = carvceEntryNode.SelectSingleNode("testConditions");
if (testConditionsNode != null)
{
queryEntry.ReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(testConditionsNode.ReadXmlElementAttr("testSequence", "gwe"));
queryEntry.ValueReturnType = DataBaseQueryValueReturnTypeConverter.FromString(testConditionsNode.ReadXmlElementAttr("valueReturnType", "RawValue"));
XmlNode goodScriptNode = testConditionsNode.SelectSingleNode("success");
queryEntry.GoodResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(goodScriptNode.ReadXmlElementAttr("testType", "match"));
queryEntry.GoodValue = goodScriptNode.InnerText;
XmlNode warningScriptNode = testConditionsNode.SelectSingleNode("warning");
queryEntry.WarningResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningScriptNode.ReadXmlElementAttr("testType", "match"));
queryEntry.WarningValue = warningScriptNode.InnerText;
XmlNode errorScriptNode = testConditionsNode.SelectSingleNode("error");
queryEntry.ErrorResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorScriptNode.ReadXmlElementAttr("testType", "match"));
queryEntry.ErrorValue = errorScriptNode.InnerText;
}
else
{
queryEntry.ReturnCheckSequence = CollectorAgentReturnValueCheckSequence.GWE;
queryEntry.ValueReturnType = DataBaseQueryValueReturnType.RawValue;
}
Entries.Add(queryEntry);
}
}
public MonitorState GetCurrentState()
{
object wsData = null;
CollectorState agentState = CollectorState.NotAvailable;
try
{
wsData = GetValue();
//if (ReturnValueIsNumber && !wsData.IsNumber())
//{
// agentState = CollectorState.Error;
// wsData = "Returned value is not a number! (" + wsData.ToString() + ")";
//}
//else
//{
CurrentAgentValue = FormatUtils.FormatArrayToString(wsData, "[null]");
agentState = CollectorAgentReturnValueCompareEngine.GetState(ReturnCheckSequence,
GoodResultMatchType, GoodValue,
WarningResultMatchType, WarningValue,
ErrorResultMatchType, ErrorValue,
CurrentAgentValue);
//}
}
catch (Exception wsException)
{
agentState = CollectorState.Error;
wsData = wsException.Message;
}
MonitorState currentState = new MonitorState()
{
ForAgent = Description,
State = agentState,
CurrentValue = wsData == null ? "N/A" : wsData.ToString(),
CurrentValueUnit = OutputValueUnit
};
return(currentState);
//object value = GetValue();
//CurrentAgentValue = value;
//MonitorState currentState = new MonitorState()
//{
// ForAgent = Name,
// CurrentValue = FormatUtils.FormatArrayToString(value, "[null]"),
// State = EvaluateValue(value)
//};
//if (currentState.State == CollectorState.Error)
//{
// currentState.RawDetails = string.Format("'{0}' - value '{1}' - Error (trigger {2})", Name, FormatUtils.FormatArrayToString(value, "[null]"), ErrorValue);
// currentState.HtmlDetails = string.Format("'{0}' - value '{1}' - <b>Error</b> (trigger {2})", Name, FormatUtils.FormatArrayToString(value, "[null]"), ErrorValue);
//}
//else if (currentState.State == CollectorState.Warning)
//{
// currentState.RawDetails = string.Format("'{0}' - value '{1}' - Warning (trigger {2})", Name, FormatUtils.FormatArrayToString(value, "[null]"), WarningValue);
// currentState.HtmlDetails = string.Format("'{0}' - value '{1}' - <b>Warning</b> (trigger {2})", Name, FormatUtils.FormatArrayToString(value, "[null]"), WarningValue);
//}
//else
//{
// currentState.RawDetails = string.Format("'{0}' - value '{1}'", Name, FormatUtils.FormatArrayToString(value, "[null]"));
// currentState.HtmlDetails = string.Format("'{0}' - value '{1}'", Name, FormatUtils.FormatArrayToString(value, "[null]"));
//}
//return currentState;
}
public void FromXml(string configurationString)
{
XmlDocument config = new XmlDocument();
config.LoadXml(configurationString);
XmlElement root = config.DocumentElement;
Entries.Clear();
foreach (XmlElement addressNode in root.SelectNodes("webServices/webService"))
{
WSCollectorConfigEntry webServicePingEntry = new WSCollectorConfigEntry();
webServicePingEntry.ServiceBaseURL = addressNode.ReadXmlElementAttr("url", "");
webServicePingEntry.ServiceBindingName = addressNode.ReadXmlElementAttr("serviceBindingName", "");
webServicePingEntry.MethodName = addressNode.ReadXmlElementAttr("method");
string parameterStr = addressNode.ReadXmlElementAttr("paramatersCSV");
webServicePingEntry.Parameters = new List <string>();
if (parameterStr.Trim().Length > 0)
{
webServicePingEntry.Parameters.AddRange(parameterStr.Split(','));
}
//webServicePingEntry.ResultIsSuccess = addressNode.ReadXmlElementAttr("resultIsSuccess", true);
webServicePingEntry.ValueExpectedReturnType = WebServiceValueExpectedReturnTypeConverter.FromString(addressNode.ReadXmlElementAttr("valueExpectedReturnType", ""));
webServicePingEntry.MacroFormatType = WebServiceMacroFormatTypeConverter.FromString(addressNode.ReadXmlElementAttr("macroFormatType", ""));
webServicePingEntry.CheckValueArrayIndex = addressNode.ReadXmlElementAttr("arrayIndex", 0);
webServicePingEntry.CheckValueColumnIndex = addressNode.ReadXmlElementAttr("columnIndex", 0);
if (addressNode.ReadXmlElementAttr("resultIsSuccess", true))
{
webServicePingEntry.ReturnCheckSequence = CollectorAgentReturnValueCheckSequence.GWE;
}
else
{
webServicePingEntry.ReturnCheckSequence = CollectorAgentReturnValueCheckSequence.EWG;
}
webServicePingEntry.GoodResultMatchType = CollectorAgentReturnValueCompareMatchType.Contains;
webServicePingEntry.GoodScriptText = addressNode.ReadXmlElementAttr("valueOrMacro", "");
if (webServicePingEntry.ValueExpectedReturnType == WebServiceValueExpectedReturnTypeEnum.CheckAvailabilityOnly)
{
webServicePingEntry.GoodScriptText = "[Available]";
}
else if (addressNode.ReadXmlElementAttr("useRegEx", false))
{
webServicePingEntry.GoodResultMatchType = CollectorAgentReturnValueCompareMatchType.RegEx;
}
else if (webServicePingEntry.GoodScriptText.StartsWith("[Between] "))
{
webServicePingEntry.GoodResultMatchType = CollectorAgentReturnValueCompareMatchType.Between;
webServicePingEntry.GoodScriptText = webServicePingEntry.GoodScriptText.Substring("[Between] ".Length);
webServicePingEntry.GoodScriptText = webServicePingEntry.GoodScriptText.Replace("[and]", "and");
}
else if (webServicePingEntry.GoodScriptText.StartsWith("[LargerThan] "))
{
webServicePingEntry.GoodResultMatchType = CollectorAgentReturnValueCompareMatchType.LargerThan;
webServicePingEntry.GoodScriptText = webServicePingEntry.GoodScriptText.Substring("[LargerThan] ".Length);
}
else if (webServicePingEntry.GoodScriptText.StartsWith("[SmallerThan] "))
{
webServicePingEntry.GoodResultMatchType = CollectorAgentReturnValueCompareMatchType.SmallerThan;
webServicePingEntry.GoodScriptText = webServicePingEntry.GoodScriptText.Substring("[SmallerThan] ".Length);
}
else if (webServicePingEntry.GoodScriptText.StartsWith("[Contains] "))
{
webServicePingEntry.GoodResultMatchType = CollectorAgentReturnValueCompareMatchType.Contains;
webServicePingEntry.GoodScriptText = webServicePingEntry.GoodScriptText.Substring("[Contains] ".Length);
}
else if (webServicePingEntry.GoodScriptText.StartsWith("[BeginsWith] "))
{
webServicePingEntry.GoodResultMatchType = CollectorAgentReturnValueCompareMatchType.StartsWith;
webServicePingEntry.GoodScriptText = webServicePingEntry.GoodScriptText.Substring("[BeginsWith] ".Length);
}
else if (webServicePingEntry.GoodScriptText.StartsWith("[EndsWith] "))
{
webServicePingEntry.GoodResultMatchType = CollectorAgentReturnValueCompareMatchType.EndsWith;
webServicePingEntry.GoodScriptText = webServicePingEntry.GoodScriptText.Substring("[EndsWith] ".Length);
}
webServicePingEntry.WarningResultMatchType = CollectorAgentReturnValueCompareMatchType.Contains;
webServicePingEntry.WarningScriptText = "[null]";
webServicePingEntry.ErrorResultMatchType = CollectorAgentReturnValueCompareMatchType.Contains;
webServicePingEntry.ErrorScriptText = "[any]";
if (webServicePingEntry.ReturnCheckSequence == CollectorAgentReturnValueCheckSequence.EWG)
{
CollectorAgentReturnValueCompareMatchType tmpMT = webServicePingEntry.GoodResultMatchType;
string tmpTestValue = webServicePingEntry.GoodScriptText;
webServicePingEntry.GoodResultMatchType = webServicePingEntry.ErrorResultMatchType;
webServicePingEntry.GoodScriptText = webServicePingEntry.ErrorScriptText;
webServicePingEntry.ErrorResultMatchType = tmpMT;
webServicePingEntry.ErrorScriptText = tmpTestValue;
}
Entries.Add(webServicePingEntry);
}
foreach (XmlElement carvceEntryNode in root.SelectNodes("carvcesEntries/carvceEntry"))
{
WSCollectorConfigEntry webServicePingEntry = new WSCollectorConfigEntry();
XmlNode dataSourceNode = carvceEntryNode.SelectSingleNode("dataSource");
webServicePingEntry.ServiceBaseURL = dataSourceNode.ReadXmlElementAttr("url", "");
webServicePingEntry.ServiceBindingName = dataSourceNode.ReadXmlElementAttr("serviceBindingName", "");
webServicePingEntry.MethodName = dataSourceNode.ReadXmlElementAttr("method", "");
string parameterStr = dataSourceNode.ReadXmlElementAttr("paramatersCSV", "");
webServicePingEntry.Parameters = new List <string>();
if (parameterStr.Trim().Length > 0)
{
webServicePingEntry.Parameters.AddRange(parameterStr.Split(','));
}
webServicePingEntry.ValueExpectedReturnType = WebServiceValueExpectedReturnTypeConverter.FromString(dataSourceNode.ReadXmlElementAttr("valueExpectedReturnType", ""));
webServicePingEntry.MacroFormatType = WebServiceMacroFormatTypeConverter.FromString(dataSourceNode.ReadXmlElementAttr("macroFormatType", ""));
webServicePingEntry.CheckValueArrayIndex = dataSourceNode.ReadXmlElementAttr("arrayIndex", 0);
webServicePingEntry.CheckValueColumnIndex = dataSourceNode.ReadXmlElementAttr("columnIndex", 0);
webServicePingEntry.PrimaryUIValue = dataSourceNode.ReadXmlElementAttr("primaryUIValue", false);
XmlNode testConditionsNode = carvceEntryNode.SelectSingleNode("testConditions");
if (testConditionsNode != null)
{
webServicePingEntry.ReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(testConditionsNode.ReadXmlElementAttr("testSequence", "gwe"));
XmlNode goodScriptNode = testConditionsNode.SelectSingleNode("success");
webServicePingEntry.GoodResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(goodScriptNode.ReadXmlElementAttr("testType", "match"));
webServicePingEntry.GoodScriptText = goodScriptNode.InnerText;
if (webServicePingEntry.ValueExpectedReturnType == WebServiceValueExpectedReturnTypeEnum.CheckAvailabilityOnly)
{
webServicePingEntry.GoodScriptText = "[Available]";
}
XmlNode warningScriptNode = testConditionsNode.SelectSingleNode("warning");
webServicePingEntry.WarningResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningScriptNode.ReadXmlElementAttr("testType", "match"));
webServicePingEntry.WarningScriptText = warningScriptNode.InnerText;
XmlNode errorScriptNode = testConditionsNode.SelectSingleNode("error");
webServicePingEntry.ErrorResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorScriptNode.ReadXmlElementAttr("testType", "match"));
webServicePingEntry.ErrorScriptText = errorScriptNode.InnerText;
}
else
{
webServicePingEntry.ReturnCheckSequence = CollectorAgentReturnValueCheckSequence.GWE;
}
Entries.Add(webServicePingEntry);
}
}
public void FromXml(string configurationString)
{
XmlDocument config = new XmlDocument();
if (configurationString == null || configurationString.Length == 0)
{
config.LoadXml(GetDefaultOrEmptyXml());
}
else
{
config.LoadXml(configurationString);
}
XmlElement root = config.DocumentElement;
Entries.Clear();
//Version 4 config
foreach (XmlElement queryNode in root.SelectNodes("queries/query"))
{
RegistryQueryCollectorConfigEntry queryEntry = new RegistryQueryCollectorConfigEntry();
queryEntry.Name = queryNode.ReadXmlElementAttr("name", "");
queryEntry.UseRemoteServer = bool.Parse(queryNode.ReadXmlElementAttr("useRemoteServer", "False"));
queryEntry.Server = queryNode.ReadXmlElementAttr("server", "");
queryEntry.RegistryHive = RegistryQueryCollectorConfigEntry.GetRegistryHiveFromString(queryNode.ReadXmlElementAttr("registryHive", ""));
queryEntry.Path = queryNode.ReadXmlElementAttr("path", "");
queryEntry.KeyName = queryNode.ReadXmlElementAttr("keyName", "");
queryEntry.ExpandEnvironmentNames = bool.Parse(queryNode.ReadXmlElementAttr("expandEnvironmentNames", "False"));
//queryEntry.ReturnValueIsNumber = bool.Parse(queryNode.ReadXmlElementAttr("returnValueIsNumber", "False"));
queryEntry.GoodValue = queryNode.ReadXmlElementAttr("successValue", "");
queryEntry.GoodResultMatchType = CollectorAgentReturnValueCompareMatchType.Match;
queryEntry.WarningValue = queryNode.ReadXmlElementAttr("warningValue", "");
queryEntry.WarningResultMatchType = CollectorAgentReturnValueCompareMatchType.Match;
queryEntry.ErrorValue = queryNode.ReadXmlElementAttr("errorValue", "");
queryEntry.ErrorResultMatchType = CollectorAgentReturnValueCompareMatchType.Match;
//queryEntry.ReturnValueInARange = bool.Parse(queryNode.ReadXmlElementAttr("returnValueInARange", "False"));
//queryEntry.ReturnValueInverted = bool.Parse(queryNode.ReadXmlElementAttr("returnValueInverted", "False"));
queryEntry.PrimaryUIValue = queryNode.ReadXmlElementAttr("primaryUIValue", false);
Entries.Add(queryEntry);
}
//version 5 config
foreach (XmlElement carvceEntryNode in root.SelectNodes("carvcesEntries/carvceEntry"))
{
XmlNode dataSourceNode = carvceEntryNode.SelectSingleNode("dataSource");
RegistryQueryCollectorConfigEntry queryEntry = new RegistryQueryCollectorConfigEntry();
queryEntry.Name = dataSourceNode.ReadXmlElementAttr("name", "");
queryEntry.UseRemoteServer = bool.Parse(dataSourceNode.ReadXmlElementAttr("useRemoteServer", "False"));
queryEntry.Server = dataSourceNode.ReadXmlElementAttr("server", "");
queryEntry.RegistryHive = RegistryQueryCollectorConfigEntry.GetRegistryHiveFromString(dataSourceNode.ReadXmlElementAttr("registryHive", ""));
queryEntry.Path = dataSourceNode.ReadXmlElementAttr("path", "");
queryEntry.KeyName = dataSourceNode.ReadXmlElementAttr("keyName", "");
queryEntry.ExpandEnvironmentNames = bool.Parse(dataSourceNode.ReadXmlElementAttr("expandEnvironmentNames", "False"));
//queryEntry.ReturnValueIsNumber = bool.Parse(dataSourceNode.ReadXmlElementAttr("returnValueIsNumber", "False"));
queryEntry.PrimaryUIValue = dataSourceNode.ReadXmlElementAttr("primaryUIValue", false);
queryEntry.OutputValueUnit = dataSourceNode.ReadXmlElementAttr("outputValueUnit", "");
XmlNode testConditionsNode = carvceEntryNode.SelectSingleNode("testConditions");
if (testConditionsNode != null)
{
queryEntry.ReturnCheckSequence = CollectorAgentReturnValueCompareEngine.CheckSequenceTypeFromString(testConditionsNode.ReadXmlElementAttr("testSequence", "gwe"));
XmlNode goodScriptNode = testConditionsNode.SelectSingleNode("success");
queryEntry.GoodResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(goodScriptNode.ReadXmlElementAttr("testType", "match"));
queryEntry.GoodValue = goodScriptNode.InnerText;
XmlNode warningScriptNode = testConditionsNode.SelectSingleNode("warning");
queryEntry.WarningResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(warningScriptNode.ReadXmlElementAttr("testType", "match"));
queryEntry.WarningValue = warningScriptNode.InnerText;
XmlNode errorScriptNode = testConditionsNode.SelectSingleNode("error");
queryEntry.ErrorResultMatchType = CollectorAgentReturnValueCompareEngine.MatchTypeFromString(errorScriptNode.ReadXmlElementAttr("testType", "match"));
queryEntry.ErrorValue = errorScriptNode.InnerText;
}
else
{
queryEntry.ReturnCheckSequence = CollectorAgentReturnValueCheckSequence.GWE;
}
Entries.Add(queryEntry);
}
}
public override MonitorState RefreshState()
{
MonitorState returnState = new MonitorState();
string lastAction = "";
int errors = 0;
int warnings = 0;
int success = 0;
double sumValue = 0;
try
{
LinuxSSHCommandCollectorConfig currentConfig = (LinuxSSHCommandCollectorConfig)AgentConfig;
returnState.CurrentValue = null;
foreach (LinuxSSHCommandEntry entry in currentConfig.Entries)
{
string value = entry.ExecuteCommand();
CollectorState currentState = CollectorAgentReturnValueCompareEngine.GetState(entry.ValueReturnCheckSequence, entry.SuccessMatchType, entry.SuccessValueOrMacro,
entry.WarningMatchType, entry.WarningValueOrMacro, entry.ErrorMatchType, entry.ErrorValueOrMacro, value);
if (value.IsNumber())
{
sumValue += Double.Parse(value.ToString());
}
if (currentState == CollectorState.Error)
{
errors++;
}
else if (currentState == CollectorState.Warning)
{
warnings++;
}
else
{
success++;
}
returnState.ChildStates.Add(
new MonitorState()
{
ForAgent = entry.Name,
State = currentState,
CurrentValue = value.ToString(),
CurrentValueUnit = ""
});
}
if (sumValue > 0)
{
returnState.CurrentValue = sumValue;
}
if (errors > 0 && warnings == 0 && success == 0) // any errors
{
returnState.State = CollectorState.Error;
}
else if (errors > 0 || warnings > 0) //any warnings
{
returnState.State = CollectorState.Warning;
}
else
{
returnState.State = CollectorState.Good;
}
}
catch (Exception ex)
{
returnState.RawDetails = ex.Message;
returnState.HtmlDetails = string.Format("<p><b>Last action:</b> {0}</p><blockquote>{1}</blockquote>", lastAction, ex.Message);
returnState.State = CollectorState.Error;
}
return(returnState);
}
public override MonitorState RefreshState()
{
MonitorState returnState = new MonitorState();
string lastAction = "";
int errors = 0;
int warnings = 0;
int success = 0;
try
{
SqlQueryCollectorConfig currentConfig = (SqlQueryCollectorConfig)AgentConfig;
returnState.RawDetails = string.Format("Running {0} queries", currentConfig.Entries.Count);
returnState.HtmlDetails = string.Format("<b>Running {0} queries</b>", currentConfig.Entries.Count);
returnState.CurrentValue = 0;
foreach (SqlQueryCollectorEntry entry in currentConfig.Entries)
{
object value = entry.GetStateQueryValue();
CollectorState currentState = CollectorAgentReturnValueCompareEngine.GetState(entry.ValueReturnCheckSequence, entry.SuccessMatchType, entry.SuccessValueOrMacro,
entry.WarningMatchType, entry.WarningValueOrMacro, entry.ErrorMatchType, entry.ErrorValueOrMacro, value);
if (value.IsNumber())
{
returnState.CurrentValue = Double.Parse(returnState.CurrentValue.ToString()) + Double.Parse(value.ToString());
}
if (currentState == CollectorState.Error)
{
errors++;
returnState.ChildStates.Add(
new MonitorState()
{
State = CollectorState.Error,
ForAgent = entry.Name,
CurrentValue = value //,
//RawDetails = string.Format("(Trigger '{0}')", entry.TriggerSummary)
});
}
else if (currentState == CollectorState.Warning)
{
warnings++;
returnState.ChildStates.Add(
new MonitorState()
{
State = CollectorState.Warning,
ForAgent = entry.Name,
CurrentValue = value //,
//RawDetails = string.Format("(Trigger '{0}')", entry.TriggerSummary)
});
}
else
{
success++;
returnState.ChildStates.Add(
new MonitorState()
{
State = CollectorState.Good,
ForAgent = entry.Name,
CurrentValue = value
});
}
}
if (errors > 0 && warnings == 0 && success == 0) // any errors
{
returnState.State = CollectorState.Error;
}
else if (errors > 0 || warnings > 0) //any warnings
{
returnState.State = CollectorState.Warning;
}
else
{
returnState.State = CollectorState.Good;
}
}
catch (Exception ex)
{
returnState.RawDetails = ex.Message;
returnState.HtmlDetails = string.Format("<p><b>Last action:</b> {0}</p><blockquote>{1}</blockquote>", lastAction, ex.Message);
returnState.State = CollectorState.Error;
}
return(returnState);
}
