/// <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; } }