/// <summary> /// The component is being initialized /// </summary> public void InitializeComponent(IBuildComponentHost host) { _host = host; _resultsCache = (IResultsCache)(_host.GetComponent(BuildComponentType.ResultsCache)); _configCache = (IConfigCache)(_host.GetComponent(BuildComponentType.ConfigCache)); _testDataProvider = (ITestDataProvider)(_host.GetComponent(BuildComponentType.TestDataProvider)); }
/// <summary> /// Cleanup /// </summary> public void ShutdownComponent() { // If the processor thread is still there then signal it to go away // Wait for QAMockHost.globalTimeOut seconds for the thread to go away or complete. If not then abort it. if (!this.processorThreadExited) { this.processorThreadExit.Set(); if (!this.processorThread.Join(QAMockHost.globalTimeOut)) { this.processorThread.Abort(); } this.processorThread = null; } // dispose all the definition object here. foreach (RequestDefinition definition in this.definitions.Values) { definition.Dispose(); } this.definitions.Clear(); this.newResults.Clear(); this.newRequests.Clear(); this.newConfigurations.Clear(); this.newRequests = null; this.newResults = null; this.newConfigurations = null; this.configurationCache = null; this.resultsCache = null; }
/// <summary> /// Constructor /// </summary> public MockHost(BuildParameters buildParameters) { _buildParameters = buildParameters; _buildParameters.ProjectRootElementCache = new ProjectRootElementCache(false); _configCache = new ConfigCache(); ((IBuildComponent)_configCache).InitializeComponent(this); // We are a logging service _loggingService = this; _legacyThreadingData = new LegacyThreadingData(); _requestEngine = new BuildRequestEngine(); ((IBuildComponent)_requestEngine).InitializeComponent(this); _resultsCache = new ResultsCache(); ((IBuildComponent)_resultsCache).InitializeComponent(this); _requestBuilder = new Microsoft.Build.UnitTests.BackEnd.BuildRequestEngine_Tests.MockRequestBuilder(); ((IBuildComponent)_requestBuilder).InitializeComponent(this); _targetBuilder = new TestTargetBuilder(); ((IBuildComponent)_targetBuilder).InitializeComponent(this); }
/// <summary> /// Call the actual implementation /// </summary> public QAResultsCache() { _resultCache = new ResultsCache(); _addCount = 0; _getCount = 0; _clearedCount = 0; }
/// <summary> /// The component is being initialized /// </summary> public void InitializeComponent(IBuildComponentHost host) { this.host = host; this.resultsCache = (IResultsCache)(this.host.GetComponent(BuildComponentType.ResultsCache)); this.configCache = (IConfigCache)(this.host.GetComponent(BuildComponentType.ConfigCache)); this.testDataProvider = (ITestDataProvider)(this.host.GetComponent(BuildComponentType.TestDataProvider)); }
private void CleanupCaches() { IConfigCache configCache = _componentFactories.GetComponent(BuildComponentType.ConfigCache) as IConfigCache; if (null != configCache) { configCache.ClearConfigurations(); } IResultsCache resultsCache = _componentFactories.GetComponent(BuildComponentType.ResultsCache) as IResultsCache; if (null != resultsCache) { resultsCache.ClearResults(); } if (Environment.GetEnvironmentVariable("MSBUILDCLEARXMLCACHEONCHILDNODES") == "1") { // Optionally clear out the cache. This has the advantage of releasing memory, // but the disadvantage of causing the next build to repeat the load and parse. // We'll experiment here and ship with the best default. s_projectRootElementCache = null; } // Since we aren't going to be doing any more work, lets clean up all our memory usage. GC.Collect(); }
/// <summary> /// Call the actual implementation /// </summary> public QAResultsCache() { this.resultCache = new ResultsCache(); this.addCount = 0; this.getCount = 0; this.clearedCount = 0; }
/// <summary> /// Creates and caches a built result. /// </summary> private BuildResult CacheBuildResult(BuildRequest request, string target, WorkUnitResult workUnitResult) { BuildResult result = CreateBuildResult(request, target, workUnitResult); IResultsCache resultsCache = _host.GetComponent(BuildComponentType.ResultsCache) as IResultsCache; resultsCache.AddResult(result); return(result); }
public OracleDbConn(string connStr , IResultsCache aResultsCache , bool commitAtFinalizing , bool debugPrint , ILogger logger) : base(connStr, aResultsCache, commitAtFinalizing, debugPrint, logger) { }
public TrendService(IIndexManager indexManager, IPostCountsCache postCountsCache, IStoryCountCache storyCountCache, IResultsCache resultsCache) { this.indexManager = indexManager ?? throw new ArgumentNullException(nameof(indexManager)); this.postCountsCache = postCountsCache ?? throw new ArgumentNullException(nameof(postCountsCache)); this.storyCountCache = storyCountCache ?? throw new ArgumentNullException(nameof(storyCountCache)); this.resultsCache = resultsCache ?? throw new ArgumentNullException(nameof(resultsCache)); }
public TrendService(IConnectionFactory connectionFactory, IPostCountsCache postCountsCache, IStoryCountCache storyCountCache, IResultsCache resultsCache) { this.connectionFactory = connectionFactory; this.postCountsCache = postCountsCache ?? throw new ArgumentNullException(nameof(postCountsCache)); this.storyCountCache = storyCountCache ?? throw new ArgumentNullException(nameof(storyCountCache)); this.resultsCache = resultsCache ?? throw new ArgumentNullException(nameof(resultsCache)); }
/// <summary> /// Constructor that takes in nothing. /// </summary> public QARequestBuilder() { _host = null; _configCache = null; _resultsCache = null; _builderThread = null; _requestedEntry = null; _cancelEvent = new AutoResetEvent(false); _continueEvent = new AutoResetEvent(false); _threadStarted = new ManualResetEvent(false); _currentProjectDefinition = null; }
/// <summary> /// Constructor that takes in nothing. /// </summary> public QARequestBuilder() { this.host = null; this.configCache = null; this.resultsCache = null; this.builderThread = null; this.requestedEntry = null; this.cancelEvent = new AutoResetEvent(false); this.continueEvent = new AutoResetEvent(false); this.threadStarted = new ManualResetEvent(false); this.currentProjectDefinition = null; }
public DbConn(string connStr , IResultsCache aResultsCache , bool commitAtFinalizing , bool debugPrint , ILogger logger) { _connStr = connStr; _aResultsCache = aResultsCache; _commitAtFinalizing = commitAtFinalizing; _debugPrint = debugPrint; _logger = logger; //次状態への遷移 this.GoToNextState(NoConnection.GetInstance()); }
/// <summary> /// Constructor /// /// UNDONE: Refactor this, and the other MockHosts, to use a common base implementation. The duplication of the /// logging implementation alone is unfortunate. /// </summary> public MockHost() { _buildParameters = new BuildParameters(); _legacyThreadingData = new LegacyThreadingData(); _configCache = new ConfigCache(); ((IBuildComponent)_configCache).InitializeComponent(this); _loggingService = this; _resultsCache = new ResultsCache(); ((IBuildComponent)_resultsCache).InitializeComponent(this); _requestBuilder = new RequestBuilder(); ((IBuildComponent)_requestBuilder).InitializeComponent(this); _targetBuilder = new TargetBuilder(); ((IBuildComponent)_targetBuilder).InitializeComponent(this); _sdkResolverService = new MockSdkResolverService(); ((IBuildComponent)_sdkResolverService).InitializeComponent(this); }
/// <summary> /// Constructor allows you to set the filname, toolsversion, targets to build, build properties and execution time. /// Following are the defaults: /// ToolsVersion = "ToolsVersion" /// GlobalProperties = new BuildPropertyGroup() /// ExecutionTime = 0; /// Targets to build = "target1" /// </summary> public RequestDefinition(string fileName, string toolsVersion, string[] targets, PropertyDictionary <ProjectPropertyInstance> properties, int executionTime, RequestDefinition[] childDefinitions, IBuildComponentHost host, bool noTargetsToBuild) { if (noTargetsToBuild || targets == null) { this.targetsToBuild = new string[] { }; } else { this.targetsToBuild = targets; } this.globalProperties = ((properties == null) ? new PropertyDictionary <ProjectPropertyInstance>() : properties); this.toolsVersion = ((toolsVersion == null) ? RequestDefinition.defaultToolsVersion : toolsVersion); this.fileName = fileName; if (childDefinitions != null) { this.childDefinitions = new List <RequestDefinition>(childDefinitions); foreach (RequestDefinition bd in childDefinitions) { this.childDefinitions.Add(bd); } } else { this.childDefinitions = new List <RequestDefinition>(); } this.testProjectCompletedEvent = new AutoResetEvent(false); this.executionTime = executionTime; this.requestEngine = (IBuildRequestEngine)host.GetComponent(BuildComponentType.RequestEngine); this.testDataProvider = (ITestDataProvider)host.GetComponent(BuildComponentType.TestDataProvider); this.resultsCache = (IResultsCache)host.GetComponent(BuildComponentType.ResultsCache); this.testDataProvider.AddDefinition(this); this.projectDefinition = new ProjectDefinition(this.fileName); this.waitForCancel = false; }
/// <summary> /// データベースに接続する /// </summary> /// <param name="dbms">DBMSの種別</param> /// <param name="connStr">接続文字列</param> /// <param name="dbParams">設定情報</param> public Db(SqlBuilder.DbmsType dbms , string connStr , DbParameters dbParams = null) { _dbms = dbms; _connStr = connStr; if (dbParams == null) { _params = new DbParameters(); } else { _params = (DbParameters)dbParams.Clone(); } //プールするDB接続を用意する _connections = new List <DbConn>(); for (int i = 0; i <= _params.ConnectionPool; i++) { _connections.Add(this.CreateDbConn()); } //キャッシュテーブルの作成 if (_params.Cache == DbParameters.CacheType.Null) { _aResultsCache = new NullResultsCache(); } else if (_params.Cache == DbParameters.CacheType.LRU) { _aResultsCache = new LruResultsCache(_params.CacheSize); } else if (_params.Cache == DbParameters.CacheType.MarkovLRU) { _aResultsCache = new MarkovResultsCache( new LruResultsCache(_params.CacheSize), this); } else { throw new InvalidEnumArgumentException("Undefined CacheType is used"); } //キャスターの生成 _aCaster = this.CreateCaster(); //SqlPodファクトリの生成 _aSqlPodFactory = new SqlPodFactory(_params.SqlPodsDir, _dbms); //テーブル情報の生成 _aTableInfoSet = new TableInfoSet(this); //レコードとテーブルのマッピング情報の生成 _aRecordViewTableMapFactory = new RecordViewTableMapFactory(this); //ロックマネージャの生成 //SQLiteの場合は、必ずSqliteLockManagerを使うこと if (_dbms == SqlBuilder.DbmsType.Sqlite) { _aLockManager = new SqliteLockManager(); } else if (_params.LockData == DbParameters.LockDataType.Memory) { _aLockManager = new MemLockManager(_aRecordViewTableMapFactory, _aCaster); } else if (_params.LockData == DbParameters.LockDataType.Db) { _aLockManager = new DbLockManager(_aRecordViewTableMapFactory, this); } else if (_params.LockData == DbParameters.LockDataType.Sqlite) { _aLockManager = new SqliteLockManager(); } else if (_params.LockData == DbParameters.LockDataType.Null) { _aLockManager = new NullLockManager(); } else { throw new InvalidEnumArgumentException("Undefined LockDataType is used"); } //SQL文発行ログの出力メソッドの作成 if (_params.Logger == DbParameters.LoggerType.Null) { _aLogger = new NullLogger(); } else if (_params.Logger == DbParameters.LoggerType.WindowsEventLog) { _aLogger = new WindowsEventLogger(); } else if (_params.Logger == DbParameters.LoggerType.Console) { _aLogger = new ConsoleLogger(); } else { throw new InvalidEnumArgumentException("Undefined LoggerType is used"); } }
/// <summary> /// Initializes the component with the specified component host. /// </summary> /// <param name="host">The component host.</param> public void InitializeComponent(IBuildComponentHost host) { _componentHost = host; _resultsCache = (IResultsCache)_componentHost.GetComponent(BuildComponentType.ResultsCache); _configCache = (IConfigCache)_componentHost.GetComponent(BuildComponentType.ConfigCache); }
/// <summary> /// Save the configuration cache information from the host /// </summary> public void InitializeComponent(IBuildComponentHost host) { this.configurationCache = (IConfigCache)host.GetComponent(BuildComponentType.ConfigCache); this.resultsCache = (IResultsCache)host.GetComponent(BuildComponentType.ResultsCache); }
public CacheAggregation(IConfigCache configCache, IResultsCache resultsCache, int lastConfigurationId) { ConfigCache = configCache; ResultsCache = resultsCache; LastConfigurationId = lastConfigurationId; }
public static string SerializeCaches(IConfigCache configCache, IResultsCache resultsCache, string outputCacheFile) { ErrorUtilities.VerifyThrowInternalNull(outputCacheFile, nameof(outputCacheFile)); try { if (string.IsNullOrWhiteSpace(outputCacheFile)) { return(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("EmptyOutputCacheFile")); } var fullPath = FileUtilities.NormalizePath(outputCacheFile); Directory.CreateDirectory(Path.GetDirectoryName(fullPath)); // Use FileStream constructor (File.OpenWrite should not be used as it doesn't reset the length of the file!) using (var fileStream = new FileStream(fullPath, FileMode.Create, FileAccess.Write, FileShare.None)) { var translator = BinaryTranslator.GetWriteTranslator(fileStream); ConfigCache configCacheToSerialize = null; ResultsCache resultsCacheToSerialize = null; switch (configCache) { case ConfigCache asConfigCache: configCacheToSerialize = asConfigCache; break; case ConfigCacheWithOverride configCacheWithOverride: configCacheToSerialize = configCacheWithOverride.CurrentCache; break; default: ErrorUtilities.ThrowInternalErrorUnreachable(); break; } switch (resultsCache) { case ResultsCache asResultsCache: resultsCacheToSerialize = asResultsCache; break; case ResultsCacheWithOverride resultsCacheWithOverride: resultsCacheToSerialize = resultsCacheWithOverride.CurrentCache; break; default: ErrorUtilities.ThrowInternalErrorUnreachable(); break; } translator.Translate(ref configCacheToSerialize); translator.Translate(ref resultsCacheToSerialize); } } catch (Exception e) { return(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("ErrorWritingCacheFile", outputCacheFile, e.Message)); } return(null); }
public MarkovResultsCache(IResultsCache resultsCache, Db aDb) { _resultsCache = resultsCache; _aDb = aDb; }
/// <summary> /// Builds the specified targets. /// </summary> /// <param name="loggingContext">The logging context for the project.</param> /// <param name="entry">The BuildRequestEntry for which we are building targets.</param> /// <param name="callback">The callback to be used to handle new project build requests.</param> /// <param name="targetNames">The names of the targets to build.</param> /// <param name="baseLookup">The Lookup containing all current items and properties for this target.</param> /// <param name="cancellationToken">The <see cref="CancellationToken"/> to use when building the targets.</param> /// <returns>The target's outputs and result codes</returns> public async Task <BuildResult> BuildTargets(ProjectLoggingContext loggingContext, BuildRequestEntry entry, IRequestBuilderCallback callback, string[] targetNames, Lookup baseLookup, CancellationToken cancellationToken) { ErrorUtilities.VerifyThrowArgumentNull(loggingContext, "projectLoggingContext"); ErrorUtilities.VerifyThrowArgumentNull(entry, nameof(entry)); ErrorUtilities.VerifyThrowArgumentNull(callback, "requestBuilderCallback"); ErrorUtilities.VerifyThrowArgumentNull(targetNames, nameof(targetNames)); ErrorUtilities.VerifyThrowArgumentNull(baseLookup, nameof(baseLookup)); ErrorUtilities.VerifyThrow(targetNames.Length > 0, "List of targets must be non-empty"); ErrorUtilities.VerifyThrow(_componentHost != null, "InitializeComponent must be called before building targets."); _requestEntry = entry; _requestBuilderCallback = callback; _projectLoggingContext = loggingContext; _cancellationToken = cancellationToken; // Clone the base lookup so that if we are re-entered by another request while this one in blocked, we don't have visibility to // their state, and they have no visibility into ours. _baseLookup = baseLookup.Clone(); _targetsToBuild = new ConcurrentStack <TargetEntry>(); // Get the actual target objects from the names BuildRequestConfiguration configuration = _requestEntry.RequestConfiguration; bool previousCacheableStatus = configuration.IsCacheable; configuration.IsCacheable = false; configuration.RetrieveFromCache(); _projectInstance = configuration.Project; // Now get the current results cache entry. IResultsCache resultsCache = (IResultsCache)_componentHost.GetComponent(BuildComponentType.ResultsCache); BuildResult existingBuildResult = resultsCache.GetResultsForConfiguration(_requestEntry.Request.ConfigurationId); _buildResult = new BuildResult(entry.Request, existingBuildResult, null); if (existingBuildResult == null) { // Add this result so that if our project gets re-entered we won't rebuild any targets we have already built. resultsCache.AddResult(_buildResult); } List <TargetSpecification> targets = new List <TargetSpecification>(targetNames.Length); foreach (string targetName in targetNames) { var targetExists = _projectInstance.Targets.ContainsKey(targetName); if (!targetExists && entry.Request.BuildRequestDataFlags.HasFlag(BuildRequestDataFlags.SkipNonexistentTargets)) { _projectLoggingContext.LogComment(Framework.MessageImportance.Low, "TargetSkippedWhenSkipNonexistentTargets", targetName); continue; } targets.Add(new TargetSpecification(targetName, targetExists ? _projectInstance.Targets[targetName].Location : _projectInstance.ProjectFileLocation)); } // Push targets onto the stack. This method will reverse their push order so that they // get built in the same order specified in the array. await PushTargets(targets, null, baseLookup, false, false, TargetBuiltReason.None); // Now process the targets ITaskBuilder taskBuilder = _componentHost.GetComponent(BuildComponentType.TaskBuilder) as ITaskBuilder; try { await ProcessTargetStack(taskBuilder); } finally { // If there are still targets left on the stack, they need to be removed from the 'active targets' list foreach (TargetEntry target in _targetsToBuild) { configuration.ActivelyBuildingTargets.Remove(target.Name); } ((IBuildComponent)taskBuilder).ShutdownComponent(); } if (_cancellationToken.IsCancellationRequested) { throw new BuildAbortedException(); } // Gather up outputs for the requested targets and return those. All of our information should be in the base lookup now. ComputeAfterTargetFailures(targetNames); BuildResult resultsToReport = new BuildResult(_buildResult, targetNames); // Return after-build project state if requested. if (_requestEntry.Request.BuildRequestDataFlags.HasFlag(BuildRequestDataFlags.ProvideProjectStateAfterBuild)) { resultsToReport.ProjectStateAfterBuild = _projectInstance; } if (_requestEntry.Request.RequestedProjectState != null) { resultsToReport.ProjectStateAfterBuild = _projectInstance.FilteredCopy(_requestEntry.Request.RequestedProjectState); } configuration.IsCacheable = previousCacheableStatus; return(resultsToReport); }
public void ShutdownComponent() { _host = null; _cache = null; }
public void InitializeComponent(IBuildComponentHost host) { _host = host; _cache = new ResultsCache(); }
/// <summary> /// Cleanup /// </summary> public void ShutdownComponent() { // If the processor thread is still there then signal it to go away // Wait for QAMockHost.globalTimeOut seconds for the thread to go away or complete. If not then abort it. if (!this.processorThreadExited) { this.processorThreadExit.Set(); if(!this.processorThread.Join(QAMockHost.globalTimeOut)) { this.processorThread.Abort(); } this.processorThread = null; } // dispose all the definition object here. foreach (RequestDefinition definition in this.definitions.Values) { definition.Dispose(); } this.definitions.Clear(); this.newResults.Clear(); this.newRequests.Clear(); this.newConfigurations.Clear(); this.newRequests = null; this.newResults = null; this.newConfigurations = null; this.configurationCache = null; this.resultsCache = null; }
/// <summary> /// Constructor allows you to set the filname, toolsversion, targets to build, build properties and execution time. /// Following are the defaults: /// ToolsVersion = "ToolsVersion" /// GlobalProperties = new BuildPropertyGroup() /// ExecutionTime = 0; /// Targets to build = "target1" /// </summary> public RequestDefinition(string fileName, string toolsVersion, string[] targets, PropertyDictionary<ProjectPropertyInstance> properties, int executionTime, RequestDefinition[] childDefinitions, IBuildComponentHost host, bool noTargetsToBuild) { if (noTargetsToBuild || targets == null) { _targetsToBuild = new string[] { }; } else { _targetsToBuild = targets; } _globalProperties = ((properties == null) ? new PropertyDictionary<ProjectPropertyInstance>() : properties); _toolsVersion = ((toolsVersion == null) ? RequestDefinition.defaultToolsVersion : toolsVersion); _fileName = fileName; if (childDefinitions != null) { _childDefinitions = new List<RequestDefinition>(childDefinitions); foreach (RequestDefinition bd in childDefinitions) { _childDefinitions.Add(bd); } } else { _childDefinitions = new List<RequestDefinition>(); } _testProjectCompletedEvent = new AutoResetEvent(false); _executionTime = executionTime; _requestEngine = (IBuildRequestEngine)host.GetComponent(BuildComponentType.RequestEngine); _testDataProvider = (ITestDataProvider)host.GetComponent(BuildComponentType.TestDataProvider); _resultsCache = (IResultsCache)host.GetComponent(BuildComponentType.ResultsCache); _testDataProvider.AddDefinition(this); _projectDefinition = new ProjectDefinition(_fileName); _waitForCancel = false; }
public ResultsCacheWithOverride(IResultsCache @override) { _override = @override; CurrentCache = new ResultsCache(); }
/// <summary> /// Constructor /// /// UNDONE: Refactor this, and the other MockHosts, to use a common base implementation. The duplication of the /// logging implementation alone is unfortunate. /// </summary> public MockHost() { _buildParameters = new BuildParameters(); _legacyThreadingData = new LegacyThreadingData(); _configCache = new ConfigCache(); ((IBuildComponent)_configCache).InitializeComponent(this); _loggingService = this; _resultsCache = new ResultsCache(); ((IBuildComponent)_resultsCache).InitializeComponent(this); _requestBuilder = new RequestBuilder(); ((IBuildComponent)_requestBuilder).InitializeComponent(this); _targetBuilder = new TargetBuilder(); ((IBuildComponent)_targetBuilder).InitializeComponent(this); }