/// <summary>
/// Get child progress item (before it's count should be set through SetPromisedChildCount).
/// </summary>
/// <returns>Child progress item</returns>
public ProgressItem GetChild()
{
lock (this._globalLock)
{
// if (this._subItems.Count >= _promisedChildCount)
// throw new InvalidOperationException("Trying to get more children that was promised");
var result = new ProgressItem();
result.ProgressChanged += (sender, args) => OnProgressChanged(args);
this._subItems.Add(result);
return(result);
}
}
private void RefreshQueries(
TreeTask treeTask,
ConcreteTemplateNodeDefinition nodeDefinition,
ProgressItem progress
)
{
log.DebugFormat("taskInfo.Connection:'{0}';nodeDefinition:'{1}'",
treeTask.Info.Connection.ConnectionGroup.ToString() ?? "?",
nodeDefinition.TemplateNode.Name ?? "?"
);
ErrorLog errorLog = new ErrorLog();
MsSqlAuditorModel model = this._treeControl._model;
DateTime startTime = DateTime.Now;
Stopwatch durationWatch = new Stopwatch();
durationWatch.Start();
using (SqlProcessor sqlProcessor = model.GetNewSqlProcessor(treeTask.CancellationSource.Token))
{
if (!treeTask.Info.Connection.IsLiveConnection)
{
sqlProcessor.SetSkipMSSQLQueries();
}
progress.SetPromisedChildCount(1);
TemplateNodeInfo templateNode = nodeDefinition.TemplateNode;
ConnectionGroupInfo group = nodeDefinition.Connection;
MultyQueryResultInfo result;
if (nodeDefinition.Group.Instance != null)
{
result = sqlProcessor.ExecuteMultyQuery(
nodeDefinition.Group,
templateNode.Queries,
progress.GetChild()
);
}
else
{
result = sqlProcessor.ExecuteMultyQuery(
group,
templateNode.Queries,
progress.GetChild(),
model.Settings.SystemSettings.MaximumDBRequestsThreadCount
);
}
if (group != null && group.Connections != null)
{
group.Connections.ForEach(
x => x.ConnectionGroup = x.ConnectionGroup ?? group
);
}
errorLog.AppendErrorLog(result);
IStorageManager storage = model.GetVaultProcessor(group);
storage.SaveRequestedData(templateNode, result);
durationWatch.Stop();
DateTime duration = new DateTime(durationWatch.Elapsed.Ticks);
storage.CurrentStorage.UpdateTreeNodeTimings(
templateNode,
startTime,
duration
);
foreach (GroupDefinition database in result.ExtractDatabases())
{
ConcreteTemplateNodeDefinition nodeDef = new ConcreteTemplateNodeDefinition(
templateNode,
database,
group
);
this._treeControl.VisualizeData(nodeDef);
}
}
}
public TreeTask BeginRefreshTask(
TreeNode treeNode,
bool hierarchically,
NodeUpdatingSource mode,
Action continueWith = null
)
{
if (treeNode == null)
{
return null;
}
ConcreteTemplateNodeDefinition templateDef =
treeNode.Tag as ConcreteTemplateNodeDefinition;
if (templateDef == null)
{
log.Debug("MSSQLServerAuditor.TreeTaskManager:BeginRefreshTask templateDef is not defined.");
return null;
}
long nodeHandle = templateDef.ComputeHandle();
if (this.RunningTasks.ContainsKey(nodeHandle))
{
return null;
}
ConnectionData connectionData = GetConnectionData(treeNode);
TreeTaskInfo taskInfo = new TreeTaskInfo
{
Connection = connectionData,
Mode = mode,
Hierarchically = hierarchically,
Note = string.Format("{0}", DateTime.Now.ToString("mm:ss")),
Handle = nodeHandle
};
TreeTask treeTask = TreeTask.Create(taskInfo);
if (this._treeControl != null)
{
treeTask.Progress.ProgressChanged +=
(sender, args) => this._treeControl.SetProgressValue((int) args.NewValue);
}
treeTask.Completed += (sender, args) =>
{
Task.Factory.StartNew(() => RemoveClosedTask(treeTask));
if (continueWith != null)
{
continueWith();
}
};
lock (this._runningTasksLock)
{
this.RunningTasks.TryAdd(taskInfo.Handle, treeTask);
}
// don't change order of Add and Subscribe!
treeTask.JobChanged += OnTaskJobChanged;
if (this._treeControl != null)
{
this._treeControl.SetInProgress(taskInfo, true, true);
}
ProgressItem progress = new ProgressItem();
RefreshNode(treeTask, null, treeNode, progress);
return treeTask;
}
private Dictionary<TemplateNodeQueryInfo, DataTable> ReadHistTable(
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode
)
{
Dictionary<TemplateNodeQueryInfo, DataTable> histTable = new Dictionary<TemplateNodeQueryInfo, DataTable>();
TemplateNodeInfo templateNodeInfo = concreteTemplateNode.TemplateNode;
ProgressItem progress = new ProgressItem();
using (SqlProcessor sqlProcessor = MsSqlAuditor.GetNewSqlProcessor(new CancellationToken()))
{
progress.SetPromisedChildCount(1);
MultyQueryResultInfo resultQuery = sqlProcessor.ExecuteMultyQuery(
connectionGroup,
templateNodeInfo.Queries,
progress.GetChild(),
Program.Model.Settings.SystemSettings.MaximumDBRequestsThreadCount,
true
);
if (resultQuery != null)
{
if (resultQuery.List != null)
{
if (resultQuery.List.Count != 0)
{
long requestId = this.Storage.MetaResultTable.GetMaxRequestId() + 1L;
DateTime timestamp = DateTime.Now;
histTable = PrepareHistoryData(resultQuery);
this.Storage.SaveMeta(
templateNodeInfo,
resultQuery,
requestId,
timestamp
);
}
}
}
}
return histTable;
}
private void RefreshNode(
TreeTask treeTask,
TreeJob parentJob,
TreeNode treeNode,
ProgressItem progress
)
{
ConcreteTemplateNodeDefinition nodeDefinition = treeNode.Tag as ConcreteTemplateNodeDefinition;
if (treeTask.CancellationSource.IsCancellationRequested)
{
return;
}
if (nodeDefinition == null)
{
return;
}
TreeJob treeJob = new TreeJob(nodeDefinition);
if (parentJob != null)
{
parentJob.AddChildJob(treeJob);
treeJob.Parent = parentJob;
}
WeakReference treeNodeRef = new WeakReference(treeNode);
treeTask.JobCompleted += (sender, args) =>
{
TreeTask task = sender as TreeTask;
if (task != null && treeNodeRef.IsAlive)
{
if (!task.CancellationSource.IsCancellationRequested)
{
TreeNode targetNode = (TreeNode) treeNodeRef.Target;
UpdateTreeCounts(targetNode, task.Info.Mode);
}
}
};
bool refreshChildren = treeTask.Info.Hierarchically;
Action refreshNodeAction = () =>
{
try
{
TemplateNodeInfo templateNode = nodeDefinition.TemplateNode;
if (templateNode == null || !nodeDefinition.NodeAvailable)
{
return;
}
templateNode.LastUpdateNode = DateTime.Now;
CurrentStorage storage = GetStorage(templateNode.ConnectionGroup);
templateNode.LoadUserParameters(storage);
if (nodeDefinition.NodeActivated)
{
RefreshQueries(treeTask, nodeDefinition, progress);
}
if (templateNode.IsLeaf())
{
return;
}
AddLoadingNode(treeNode);
templateNode.UpdateChildren(treeTask.Info.Mode, treeTask.CancellationSource);
FillTreeNodes(templateNode, treeNode.Nodes);
if (refreshChildren)
{
treeJob.PromisedChildCount = treeNode.Nodes.Count;
foreach (TreeNode node in treeNode.Nodes)
{
if (node != null)
{
RefreshNode(treeTask, treeJob, node, progress);
}
}
}
}
catch (Exception exc)
{
log.Error("MSSQLServerAuditor.Managers:RefreshNode:subTask (Exception)", exc);
}
};
treeJob.Action = refreshNodeAction;
lock (this._schedulingLock)
{
treeTask.Schedule(treeJob);
}
}
internal DataTable[] ExecuteSql(
InstanceInfo instance,
QueryItemInfo sql,
string database = null,
IEnumerable<QueryParameterInfo> parameters = null,
IEnumerable<ParameterValue> parameterValues = null,
ProgressItem progress = null,
bool fromGroupSelect = false
)
{
Exception gotException = null;
List<DataTable> tables = new List<DataTable>();
this._cancellationToken.ThrowIfCancellationRequested();
try
{
if (sql == null)
{
throw new Exception("There is no sql statement to execute (QueryItemInfo == null).");
}
List<Tuple<int, string>> parametersQueueForODBC;
using (IQueryConnection connection = _queryConnectionFactory.CreateQueryConnection(sql.ParentQuery.Source, instance))
{
using (IQueryCommand sqlCommand = connection.GetCommand(sql.Text, this._model.Settings.SqlTimeout, parameters, out parametersQueueForODBC))
{
using (new TryFinally(connection.Open, connection.Close))
{
connection.ChangeDatabase(database);
var shouldExecute = true;
if (sql.ExecuteIfSqlText != null)
{
var clone = sql.Clone();
clone.ExecuteIfSqlText = null;
clone.Text = sql.ExecuteIfSqlText;
DataTable[] tt = ExecuteSql(
instance,
clone,
database,
parameters,
parameterValues,
progress,
fromGroupSelect
);
if (tt.Length > 0 && tt[0].Rows.Count > 0)
{
shouldExecute = (int)(tt[0].Rows[0][0]) == 1;
}
}
if (shouldExecute)
{
var executionFinishedEvent = new AutoResetEvent(false);
IQueryCommand command = null;
Action<IAsyncResult> handleCallback = result =>
{
command = (IQueryCommand)result.AsyncState;
try
{
using (var reader = command.EndExecuteReader(result))
{
while (!reader.IsClosed)
{
DataTable table = new DataTable();
table.Load(reader, LoadOption.OverwriteChanges, ExecuteSqlFillErrorHandler);
tables.Add(table);
}
}
}
catch (Exception ex)
{
log.Error(ex);
gotException = ex;
if (fromGroupSelect)
{
log.ErrorFormat(
"Instance:'{0}';Authentication:'{1}';SQL:'{2}';Exception:'{3}'",
instance.Instance,
instance.Authentication,
sql,
ex
);
}
}
finally
{
if (command != null)
{
command.Cancel();
}
executionFinishedEvent.Set();
}
};
sqlCommand.AssignParameters(parameters, parameterValues, parametersQueueForODBC);
var callback = new AsyncCallback(handleCallback);
var asyncResult = sqlCommand.BeginExecuteReader(callback);
if (WaitHandle.WaitAny(new[] { asyncResult.AsyncWaitHandle, this._cancellationToken.WaitHandle }) == 1)
{
if (command != null)
{
command.Cancel();
}
this._cancellationToken.ThrowIfCancellationRequested();
}
executionFinishedEvent.WaitOne();
}
}
}
}
}
catch (Exception ex)
{
log.Error(ex);
if (gotException == null)
{
gotException = ex;
if (fromGroupSelect)
{
log.ErrorFormat(
"Instance:'{0}';Authentication:'{1}';Exception:'{2}'",
instance.Instance,
instance.Authentication,
ex
);
}
}
}
finally
{
if (progress != null)
{
progress.SetProgressDone();
}
}
if (gotException != null)
{
if (!fromGroupSelect)
{
gotException.Data.Add("IgnoreLog", true);
}
throw gotException;
}
return tables.ToArray();
}
/// <summary>
/// Executes multyquery
/// </summary>
/// <param name="connectionGroup">Connection group</param>
/// <param name="templateNodeQueryInfos">Template nodes</param>
/// <param name="progress">Progress item</param>
/// <param name="maxthreadCount">Maximum thread</param>
/// <returns>Multyquery result</returns>
public MultyQueryResultInfo ExecuteMultyQuery(
ConnectionGroupInfo connectionGroup,
List<TemplateNodeQueryInfo> templateNodeQueryInfos,
ProgressItem progress,
int maxthreadCount,
bool checkHist = false
)
{
Settings.InstanceTemplate settings = null;
////////////////////////////////////////////////////////////////////////////////////////
// string strLogMessage = "DEBUG:MSSQLServerAuditor.Model.ExecuteMultyQuery(1)";
// strLogMessage = strLogMessage + ";GD:" + connectionGroup.ToString();
// log.Debug(strLogMessage);
////////////////////////////////////////////////////////////////////////////////////////
var result = new MultyQueryResultInfo();
if (templateNodeQueryInfos.Count > 0)
{
progress.SetPromisedChildCount(templateNodeQueryInfos.Count);
foreach (var qi in templateNodeQueryInfos)
{
TemplateNodeQueryInfo queryInfo = qi;
QueryResultInfo queryResult = null;
try
{
var queries = this._model.GetQueryByTemplateNodeQueryInfo(queryInfo);
if (this._skipMsSqlQueries)
{
queries.RemoveAll(
x => (
x.Source == QuerySource.MSSQL
|| x.Source == QuerySource.TDSQL
)
);
}
if (checkHist)
{
queries.RemoveAll(x => (x.Source != QuerySource.SQLite));
}
else
{
queries.RemoveAll(x => (x.Source == QuerySource.SQLite));
}
if (queryInfo.ConnectionsSelectId == null)
{
if (!queries.Any(
x => connectionGroup.Connections.Select(y => y.Type).Contains(x.Source)
|| x.Source == QuerySource.SQLite
))
{
continue;
}
}
// var settings = Program.Model.TemplateSettings.UserSettings.FirstOrDefault(i =>
// i.TemplateName == connectionGroup.TemplateFileName
// && i.Connection.ParentKey == queryInfo.TemplateNode.IdsHierarchy
// );
if (Program.Model != null)
{
settings = Program.Model.TemplateSettings.UserSettings.FirstOrDefault(i =>
i.TemplateName == connectionGroup.TemplateFileName
&& i.Connection.ParentKey == queryInfo.TemplateNode.IdsHierarchy
);
}
else
{
settings = this._model.TemplateSettings.UserSettings.FirstOrDefault(i =>
i.TemplateName == connectionGroup.TemplateFileName
&& i.Connection.ParentKey == queryInfo.TemplateNode.IdsHierarchy
);
}
queryInfo.ReadParametersFrom(settings);
string connectionsSelectId = queryInfo.ConnectionsSelectId;
if (connectionsSelectId != null)
{
queryResult = ExecuteConnectionsSelectQuery(
queryInfo,
connectionGroup,
queries,
maxthreadCount
);
}
else
{
queryResult = ExecuteQuery(
connectionGroup,
queries,
QueryExecutionParams.CreateFrom(queryInfo),
maxthreadCount, progress.GetChild()
);
}
}
catch (OperationCanceledException ex)
{
log.Error(queryInfo.ToString(), ex);
throw;
}
catch (AggregateException ex)
{
if (ex.InnerExceptions.All(e => e is OperationCanceledException))
{
throw;
}
queryResult = new QueryResultInfo(
new ErrorInfo(
ex.InnerExceptions.FirstOrDefault(
e => !(e is OperationCanceledException)
)
)
);
progress.GetChild().SetProgress(100);
log.Error(queryInfo.ToString(), ex);
}
catch (Exception ex)
{
queryResult = new QueryResultInfo(new ErrorInfo(ex));
progress.GetChild().SetProgress(100);
log.Error(queryInfo.ToString(), ex);
}
result.Add(new TemplateNodeResultItem(queryInfo, queryResult));
}
}
else
{
progress.SetProgress(100);
}
return result;
}
private QueryDatabaseResultInfo ExecuteQueryItem(
InstanceInfo connection,
QueryItemInfo queryItem,
string database,
string databaseId,
IEnumerable<QueryParameterInfo> parameters,
IEnumerable<ParameterValue> parameterValues,
ProgressItem progress = null
)
{
try
{
var table = ExecuteSql(
connection,
queryItem,
database,
parameters,
parameterValues,
progress
);
return new QueryDatabaseResultInfo(table, queryItem, database, databaseId);
}
catch (OperationCanceledException ex)
{
return new QueryDatabaseResultInfo(new ErrorInfo(ex), queryItem, database, databaseId);
}
catch (Exception ex)
{
log.Error(ex);
if (!ex.Data.Contains("IgnoreLog"))
{
log.Error(queryItem.ToString() + Environment.NewLine
+ "connection.Instance=" + connection.Instance +
Environment.NewLine
+ " database=" + database + Environment.NewLine
+ " connection.Authentication.Username=" +
connection.Authentication.Username, ex);
}
if (progress != null)
{
progress.SetProgress(100);
}
return new QueryDatabaseResultInfo(new ErrorInfo(ex), queryItem, database, databaseId);
}
}
internal DataTable[] ExecuteSql(
InstanceInfo instance,
QueryInfo query,
string database = null,
IEnumerable<QueryParameterInfo> parameters = null,
IEnumerable<ParameterValue> parameterValues = null,
ProgressItem progress = null,
bool fromGroupSelect = false
)
{
InstanceVersion ver = instance.ServerProperties.Version;
QueryItemInfo exactSqlVersion = query.Items.GetQueryItemForVersion(ver);
if (exactSqlVersion == null)
{
throw new InvalidOperationException("No <sql-select-text> found for version " + ver + " in <sql-select name=" + query.Name);
}
return ExecuteSql(
instance,
exactSqlVersion,
database,
parameters,
parameterValues,
progress,
fromGroupSelect
);
}
/// <summary>
/// The execute query.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="query">The query.</param>
/// <param name="parameterValues">The parameter values.</param>
/// <param name="progress">The progress.</param>
/// <returns>
/// The <see cref="QueryInstanceResultInfo" />.
/// </returns>
private QueryInstanceResultInfo ExecuteQuery(
InstanceInfo instance,
QueryInfo query,
QueryExecutionParams parameters,
ProgressItem progress = null
)
{
try
{
var factory = new QueryExecutorFactory(instance, this.ExecuteQueryItem, this.ExecuteSql);
CurrentStorage storage = this._model.GetVaultProcessor(
instance.ConnectionGroup).CurrentStorage;
ServerProperties props = instance.InitServerProperties(storage);
return factory
.GetExecutor(query.Scope)
.ExecuteQuery(query, parameters, props.Version, progress);
}
catch (OperationCanceledException ex)
{
return new QueryInstanceResultInfo(new ErrorInfo(ex), instance);
}
catch (Exception ex)
{
if (instance.IsEnabled && !ex.Data.Contains("IgnoreLog"))
{
log.Error(query.ToString(), ex);
}
if (progress != null)
{
progress.SetProgressCanceled();
}
return new QueryInstanceResultInfo(new ErrorInfo(ex), instance);
}
}
private QueryResultInfo ExecuteQuery(
ConnectionGroupInfo connectionGroupInfo,
List<QueryInfo> queries,
QueryExecutionParams parameters,
int maxthreadCount,
ProgressItem progress = null
)
{
var result = new QueryResultInfo();
List<InstanceInfo> connections = connectionGroupInfo.Connections;
if (progress != null)
{
progress.SetPromisedChildCount(connections.Count);
}
ParallelOptions op = new ParallelOptions { MaxDegreeOfParallelism = (maxthreadCount == 0 ? Int32.MaxValue : maxthreadCount) };
Parallel.ForEach(connections, op, (connection) =>
{
var query = queries.FirstOrDefault(x => x.Source == (connection.Type) || x.Source == QuerySource.SQLite);
if (query != null)
{
ProgressItem subProgress = null;
if (progress != null)
{
subProgress = progress.GetChild();
}
result.AddInstanceResult(ExecuteQuery(connection, query, parameters, subProgress));
}
});
return result;
}
private QueryResultInfo ExecuteQuery(
GroupDefinition groupDefinition,
QueryInfo query,
QueryExecutionParams parameters,
ProgressItem progress = null
)
{
QueryResultInfo queryResult = new QueryResultInfo();
InstanceInfo instance = groupDefinition.Instance;
QueryExecutorFactory factory = new QueryExecutorFactory(
instance,
this.ExecuteQueryItem,
this.ExecuteSql
);
BaseQueryExecutor executor = factory.GetExecutor(
query.Scope
);
CurrentStorage storage = this._model.GetVaultProcessor(
instance.ConnectionGroup).CurrentStorage;
ServerProperties props = instance.InitServerProperties(storage);
QueryInstanceResultInfo instanceResult = executor.ExecuteQuerySimple(
query,
parameters,
props.Version,
progress,
groupDefinition
);
queryResult.AddInstanceResult(instanceResult);
return queryResult;
}
/// <summary>
/// Executes multyquery for database
/// </summary>
/// <param name="group">Database definition</param>
/// <param name="templateNodeQueryInfos">Template nodes</param>
/// <param name="progress">Progress item</param>
/// <returns>Multyquery result</returns>
public MultyQueryResultInfo ExecuteMultyQuery(
GroupDefinition @group,
List<TemplateNodeQueryInfo> templateNodeQueryInfos,
ProgressItem progress
)
{
////////////////////////////////////////////////////////////////////////////////////////
// string strLogMessage = "DEBUG:MSSQLServerAuditor.Model.ExecuteMultyQuery(2)";
// strLogMessage = strLogMessage + ";GD:" + @group.ToString();
// log.Debug(strLogMessage);
////////////////////////////////////////////////////////////////////////////////////////
MultyQueryResultInfo result = new MultyQueryResultInfo();
progress.SetPromisedChildCount(templateNodeQueryInfos.Count);
foreach (TemplateNodeQueryInfo queryInfo in templateNodeQueryInfos)
{
List<QueryInfo> queries = this._model.GetQueryByTemplateNodeQueryInfo(queryInfo);
QueryInfo query = queries.FirstOrDefault(x =>
x.Source == (@group.Instance.Type) || x.Source == QuerySource.SQLite);
if ((query.Source == QuerySource.MSSQL || query.Source == QuerySource.TDSQL) && this._skipMsSqlQueries)
{
continue;
}
QueryExecutionParams parameters = QueryExecutionParams.CreateFrom(queryInfo);
QueryResultInfo queryResult = ExecuteQuery(
@group,
query,
parameters,
progress.GetChild()
);
result.Add(new TemplateNodeResultItem(queryInfo, queryResult));
if (this._cancellationToken.IsCancellationRequested)
{
break;
}
}
return result;
}
/// <summary>
/// Get child progress item (before it's count should be set through SetPromisedChildCount).
/// </summary>
/// <returns>Child progress item</returns>
public ProgressItem GetChild()
{
lock (this._globalLock)
{
// if (this._subItems.Count >= _promisedChildCount)
// throw new InvalidOperationException("Trying to get more children that was promised");
var result = new ProgressItem();
result.ProgressChanged += (sender, args) => OnProgressChanged(args);
this._subItems.Add(result);
return result;
}
}
