private void DisplayAllTfsVariables(TfsVariable tfsVariables) { foreach (var item in tfsVariables.RawData) { WriteDetail(item.Key + " - " + item.Value); } }
public override TaskStatu Job(TfsVariable tfsVariables, UserVariable <PartialUnitTestSetting> usrVariables) { var setting = usrVariables.Config; if (setting == null) { return(new TaskStatu("PUT01", "No setting found.")); } var changedAll = TFSHelper.ChangedFiles(); if (!changedAll.Any()) { return(new TaskStatu("No code change found on TFS")); } var codes = changedAll.Where(x => x.FilePath.EndsWith(".cs")).ToList(); var codesChanged = codes.Where(x => x.State == SourceControlFileState.Changed).ToList(); var codesAdded = codes.Where(x => x.State == SourceControlFileState.Added).ToList(); if (codesChanged.Count + codesAdded.Count < 1) { return(new TaskStatu("No code changes found to check for partial unit test")); } var tmpFile = codesChanged.Any() ? codesChanged[0] : codesAdded[0]; Solution gSolution = GetSolutionInfo(tfsVariables, setting, tmpFile); if (gSolution == null) { return(new TaskStatu("PUT03", "No suitable solution found")); } var tmpMethodsforChanged = GetChangeforChangedFiles(codesChanged, tfsVariables, gSolution); if (tmpMethodsforChanged == null) { return(new TaskStatu("PUT04", "No suitable project document found for changed list")); } var tmpMethodsforAdded = GetChangeforChangedAdded(codesAdded, tfsVariables, gSolution); if (tmpMethodsforAdded == null) { return(new TaskStatu("PUT05", "No suitable project document found for added list")); } int totalMethod = tmpMethodsforAdded.MethodCount + tmpMethodsforChanged.MethodCount; WriteDetail(string.Format("{0} number of methods will be looked for unit test", totalMethod)); var unitTesttoCheck = CheckforUnitTest(setting, gSolution, tfsVariables, tmpMethodsforChanged, tmpMethodsforAdded); if (unitTesttoCheck == null) { return(new TaskStatu("PUT06", "No unit test found for partial check")); } bool isAllSucc = RunUnitTests(tfsVariables, setting, unitTesttoCheck, usrVariables.WorkingPath); return(isAllSucc ? new TaskStatu("Partial Unit Test check successful") : new TaskStatu("PUT07", "Partial Unit Test failed")); }
public static TaskList Get(Dictionary <string, string> tfsVariables, Dictionary <string, string> usrVar) { try { var settTfs = new TfsVariable(tfsVariables); var settUsr = new UserVariable <RawBasicBuildSetting>(RawBasicBuildSetting.KeyBaseConfigArea, usrVar); Logger.Set(settUsr.WorkingPath); if (settUsr.Config == null) { throw new Exception("User Setting File is missing or wrongly formatted."); } var dlls = GetDllList(settUsr.WorkingPath); var allTasks = GetAllTasks(dlls, settUsr); allTasks = ReOrder(settUsr, allTasks); return(allTasks); } catch (Exception ex) { Logger.Write(ex); throw; } }
public override TaskStatu Job(TfsVariable tfsVariables, UserVariable <RawBasicBuildSetting> usrVariables) { Stopwatch tmrWatch = Stopwatch.StartNew(); TaskStatu tsk = new TaskStatu("TestAsyncTask at begining."); folderPath = tfsVariables.AgentWorkFolder; var fMsg = CheckFileOp(folderPath); if (!string.IsNullOrEmpty(fMsg)) { return(new TaskStatu("T1", "CheckFileOp failed. Ex = " + fMsg)); } try { var thr = new Thread(new ThreadStart(TestPostRun)); thr.Start(); tsk = new TaskStatu("TestAsyncTask started."); } catch (Exception ex) { Logger.Write(ex); tsk = new TaskStatu("T2", "TestAsyncTask.Job's ThreadStart start throw exception. Ex = " + ex.ToString()); } return(tsk); }
public TFSClientLogic(TfsVariable tfsVar) : base(tfsVar) { idService = TeamColl.GetService(typeof(IIdentityManagementService)) as IIdentityManagementService; tfsId = IdentityService.ReadIdentity(IdentitySearchFactor.DisplayName, initSetting.BuildRequestedUser, MembershipQuery.None, ReadIdentityOptions.None); }
private ShellStatu RunTask(Func <string, string, string, Dictionary <string, string>, Dictionary <string, string>, ShellStatu> tsk) { var dictTfs = DummyTfsVariable(); var dictUsr = DummyUserVariable(); var tfs = new TfsVariable(dictTfs); var usr = new UserVariable <RawBasicBuildSetting>("", dictUsr); return(tsk("xFile", "xClass", "xMethod", dictTfs, dictUsr)); }
public void TfsHelperTest() { var dictTfs = DummyTfsVariable(); var tfs = new TfsVariable(dictTfs); TFSHelper.Initialize(tfs); var usrGroups = TFSHelper.GroupUserJoined(); Assert.IsTrue(usrGroups.Count > 0); }
public override TaskStatu Job(TfsVariable tfsVariables, UserVariable <CodeMetricSetting> usrVariables) { var setting = usrVariables.Config; if (setting == null) { return(new TaskStatu("CM01", "No setting found")); } string buildPath = tfsVariables.BuildSourceDirectory; var solutionsPath = SolutionHelper.FindSolutionFiles(buildPath); solutionsPath = !string.IsNullOrEmpty(tfsVariables.SolutiontoBuild) ? solutionsPath.Where(x => x.Contains(tfsVariables.SolutiontoBuild)).ToArray() : solutionsPath; if (!solutionsPath.Any()) { return(new TaskStatu("CM02", "No solution file found")); } foreach (var slnPath in solutionsPath) { if (setting.ExcludedSolutions.Any(x => x == slnPath)) { continue; } using (var slnProvider = new SolutionProvider()) { var solution = slnProvider.Get(slnPath).Result; var slnName = Path.GetFileName(slnPath); var projects = solution.Projects.ToList(); if (!projects.Any()) { return(new TaskStatu("CM03", string.Format("No solution found in [{0}] solution", slnName))); } WriteDetail(string.Format("Calculating metrics for [{0}] solution", slnName)); var metricBag = GetSolutionMetric(projects, solution, setting); if (metricBag == null) { return(new TaskStatu("CM04", "CodeMetric failed due to an project build or style error.")); } var checkResult = CheckMetric(metricBag, setting, slnName); if (!string.IsNullOrEmpty(checkResult)) { return(new TaskStatu("CM05", checkResult)); } } } return(new TaskStatu("CodeMetrics check finished successfully.")); }
public override TaskStatu Job(TfsVariable tfsVariables, UserVariable <RawBasicBuildSetting> usrVariables) { Stopwatch tmrWatch = Stopwatch.StartNew(); TaskStatu tsk = new TaskStatu("TestTask start successfully"); DisplayAllTfsVariables(tfsVariables); DisplayAllChangedFiles(tfsVariables); WriteDetail("This how to use detail method :)", tmrWatch); return(tsk); }
private static string FindRightOutputDll(string outputFilePath, TfsVariable tfsVariables) { string buildMode = string.IsNullOrEmpty(tfsVariables.BuildConfiguration) ? "" : tfsVariables.BuildConfiguration.ToLowerInvariant(); if (buildMode == "release") { return(outputFilePath.Replace(@"\bin\Debug\", @"\bin\Release\")); } return(outputFilePath); }
private bool RunStyleCopRules(List <string> srcFilestoCheck, TfsVariable tfsVariables, UserVariable <StyleCopSetting> usrVariables) { List <string> addInPaths = new List <string> { usrVariables.WorkingPath }; string styleSettingFile = FindRuleFile(usrVariables); // Create the StyleCop console. But do not initialise the addins as this can cause modal dialogs to be shown on errors var console = new StyleCopConsole(styleSettingFile, false, "StyleCopXmlOutputFile.xml", null, false); // make sure the UI is not dispayed on error console.Core.DisplayUI = false; // declare the add-ins to load console.Core.Initialize(addInPaths, true); // Create the configuration. Configuration configuration = new Configuration(new string[0]); // Create a CodeProject object for these files. we use a time stamp for the key and the current directory for the cache location CodeProject project = new CodeProject(DateTime.Now.ToLongTimeString().GetHashCode(), @".\", configuration); foreach (var itmFile in srcFilestoCheck) { console.Core.Environment.AddSourceCode(project, itmFile, null); } try { // Subscribe to events console.OutputGenerated += this.OnOutputGenerated; console.ViolationEncountered += this.OnViolationEncountered; // Analyze the source files CodeProject[] projects = new[] { project }; var startResult = console.Start(projects, true); } catch (Exception ex) { Logger.Write(ex); } finally { // Unsubscribe from events console.OutputGenerated -= this.OnOutputGenerated; console.ViolationEncountered -= this.OnViolationEncountered; } return(violateError.Count <= usrVariables.Config.MaxErrorCount); }
private bool CalculateCoverage(TfsVariable tfsVariables, PartialUnitTestSetting setting, List <VstestConsoleParser> cmdResults) { try { foreach (var itmOut in cmdResults) { WriteDetail($"[{Path.GetFileName(itmOut.CoverageFilePath)}] file is starting to read."); using (var coverInfo = CoverageInfo.CreateFromFile(itmOut.CoverageFilePath)) { var dllName = itmOut.AssemblyName.ToLowerInvariant(); foreach (var module in coverInfo.Modules) { if (module.Name != dllName) { continue; } byte[] coverageBuffer = module.GetCoverageBuffer(null); using (var reader = module.Symbols.CreateReader()) { uint methodId; string mthdName, undecoratedMthd, className, namespaceName; var lines = new List <BlockLineRange>(); while (reader.GetNextMethod(out methodId, out mthdName, out undecoratedMthd, out className, out namespaceName, lines)) { var stats = CoverageInfo.GetMethodStatistics(coverageBuffer, lines); string tmpUnitName = namespaceName + "." + className + "." + mthdName; string mLine = $"Covered/NotCovered => Block - Line : {stats.BlocksCovered} / {stats.BlocksNotCovered} - {stats.LinesCovered} / {stats.LinesNotCovered} => {tmpUnitName} "; WriteDetail(mLine); } } } } } return(true); } catch (Exception ex) { WriteDetail($"Coverage calculation failed : {ex}"); } return(false); }
private void DisplayAllChangedFiles(TfsVariable tfsVariables) { var files = TFSHelper.ChangedFiles(); if (files.Any()) { WriteDetail("Changed files are : "); foreach (var itm in files) { WriteDetail(itm.State + " : " + itm.FilePath); } } else { WriteDetail("No changed files found"); } }
/// <summary> /// This is where shell script trigger. A cocoon ;) /// </summary> /// <param name="dllName"></param> /// <param name="className"></param> /// <param name="methodName"></param> /// <param name="tfsVarRaw"></param> /// <param name="usrVarRaw"></param> /// <returns></returns> public ShellStatu Initializer(string dllName, string className, string methodName, Dictionary <string, string> tfsVarRaw, Dictionary <string, string> usrVarRaw) { Stopwatch watchGeneral = Stopwatch.StartNew(); string taskLongName = string.Empty; try { taskLongName = Path.GetFileNameWithoutExtension(dllName) + " -> " + className; var tfsVar = new TfsVariable(tfsVarRaw); var usrVar = new UserVariable <Tsetting>(this.GetType().Name, usrVarRaw); Logger.Set(usrVar.WorkingPath); var bsSetting = usrVar.Config; if (bsSetting == null) { return(new ShellStatu(false, string.Format("{0}.{1} tasks setting could not deserialized.", className, methodName))); } TFSHelper.Initialize(tfsVar); Stopwatch watchTask = Stopwatch.StartNew(); var tmpResult = Job(tfsVar, usrVar); watchTask.Stop(); if (intrDetailContainer.Any() && !tmpResult.Detail.Any()) { tmpResult.Detail = intrDetailContainer; } var rtnData = tmpResult == null ? new ShellStatu() : tmpResult.ToShellStatu(taskLongName); watchGeneral.Stop(); rtnData.Msgs.Add(string.Format("*** FINISH > [{0}] task runned/total (ms) : {1}/{2}", className, watchTask.Elapsed.TotalMilliseconds, watchGeneral.Elapsed.TotalMilliseconds)); rtnData.Msgs.Add("---------------------------------------"); return(rtnData); } catch (Exception ex) { Logger.Write(ex); return(new ShellStatu(false, string.Format("!!! BaseTask.Initializer failed. TaskName = [{0}]. ExDetail = [{1}].", taskLongName, ex))); } }
public override TaskStatu Job(TfsVariable tfsVariables, UserVariable <FileControlSetting> usrVariables) { var setting = usrVariables.Config; if (setting == null) { return(new TaskStatu("No setting found.")); } var allFiles = TFSHelper.ChangedFiles(); if (!allFiles.Any()) { return(new TaskStatu("No changed file found.")); } string adName = TFSHelper.UserDomainName; var usrGroups = TFSHelper.GroupUserJoined(); foreach (var sourceData in allFiles) { var sourceFile = sourceData.FilePath; var rule = setting.Files.FirstOrDefault(x => x.FileNames.Any(y => sourceFile.EndsWith(y))); if (rule == null) { continue; } if (rule.AllowedUser.Any(x => x == adName)) { continue; } if (rule.AllowedGroup.Any(x => (usrGroups.Any(y => y.EndsWith(x))))) { continue; } return(new TaskStatu("FC01", string.Format("[{0}] file is restirected for [{1}] user.", sourceFile, adName))); } return(new TaskStatu(string.Format("All changes controlled successfully. FileCount/TotalRule = {0}/{1}.", allFiles.Count, setting.Files.Count))); }
public override TaskStatu Job(TfsVariable tfsVariables, UserVariable <StyleCopSetting> usrVariables) { GlobalSetting = usrVariables?.Config; SourceBaseFolder = tfsVariables.BuildSourceDirectory; if (GlobalSetting == null) { return(new TaskStatu("SCT02", "No setting loaded.")); } bool isExcFilesExist = GlobalSetting.ExcludedFiles.Any(); bool isExcProjectsExist = GlobalSetting.ExcludedProjects.Any(); SourceBaseFolder = tfsVariables.BuildSourceDirectory; WriteDetail("Source Folder : " + SourceBaseFolder); WriteDetail("Exclusion files : " + (isExcFilesExist ? string.Join(", ", GlobalSetting.ExcludedFiles) : "None")); WriteDetail("Exclusion projects : " + (isExcFilesExist ? string.Join(", ", GlobalSetting.ExcludedProjects) : "None")); var srcFilesAll = Directory.GetFiles(SourceBaseFolder, "*.cs", SearchOption.AllDirectories).ToList(); List <string> srcFilestoCheck; if (isExcFilesExist || isExcProjectsExist) { srcFilestoCheck = FilterFiles(srcFilesAll, GlobalSetting.ExcludedFiles, GlobalSetting.ExcludedProjects); } else { srcFilestoCheck = srcFilesAll; } WriteDetail(string.Format("File Count (Check/All) : {0}/{1}", srcFilestoCheck.Count, srcFilesAll.Count)); bool isResultOk = RunStyleCopRules(srcFilestoCheck, tfsVariables, usrVariables); if (!IsRunned) { return(new TaskStatu("SCT03", "StyleCop engine did not runned.")); } return(isResultOk ? new TaskStatu("StyleCopTask finished successfully") : new TaskStatu("SCT04", "There is too much error.")); }
private bool RunUnitTests(TfsVariable tfsVariables, PartialUnitTestSetting setting, List <UnitTestDetail> unitTesttoCheck, string workingPath) { Stopwatch watch = Stopwatch.StartNew(); string cmdRaw = string.IsNullOrEmpty(setting.RunSettingFile) ? cmdParams : cmdParams + " /Settings:{2}"; var groupedUnitTest = unitTesttoCheck.GroupBy(x => x.AssemblyPath); bool isSucc = false; var cmdResults = new List <VstestConsoleParser>(); foreach (var itmGrp in groupedUnitTest) { var sb = new StringBuilder(); foreach (var itmUnitTest in itmGrp) { sb.Append(itmUnitTest.MethodName + ","); } string tstMethodLine = sb.ToString().TrimEnd(','); string settFile = Path.Combine(workingPath, setting.RunSettingFile); WriteDetail($"Unit Test Setting file found : {File.Exists(settFile)}. Path = [{settFile}]"); string prms = string.Format(cmdRaw, itmGrp.Key, tstMethodLine, settFile); var runResult = RunMsUnitTestExe(prms, itmGrp.Key); cmdResults.Add(runResult); DisplayResult(runResult, itmGrp.Key, tstMethodLine); isSucc = runResult.IsAllSucceeded; if (!isSucc) { break; } } if (isSucc && cmdResults.Any()) { isSucc &= CalculateCoverage(tfsVariables, setting, cmdResults); } WriteDetail("All test methods runned", watch); return(isSucc); }
private Solution GetSolutionInfo(TfsVariable tfsVariables, PartialUnitTestSetting setting, TFSFileState itmChanged) { bool isSolutionSelected = !string.IsNullOrEmpty(tfsVariables.SolutiontoBuild); string slnPath = null; string[] slnFiles = isSolutionSelected ? SolutionHelper.FindSolutionFiles(tfsVariables.BuildSourceDirectory, tfsVariables.SolutiontoBuild) : SolutionHelper.FindSolutionFiles(tfsVariables.BuildSourceDirectory); if (isSolutionSelected) { slnPath = slnFiles.FirstOrDefault(); } else { foreach (var slnFullPath in slnFiles) { string mainFolderName = Path.GetDirectoryName(slnFullPath); var mainFolder = new DirectoryInfo(mainFolderName); var repoFolder = mainFolder.Parent.FullName; string tmpFile = repoFolder + itmChanged.FilePath; if (File.Exists(tmpFile)) { slnPath = slnFullPath; break; } } if (string.IsNullOrEmpty(slnPath)) { return(null); } } MSBuildWorkspace workSpace = MSBuildWorkspace.Create(); var solution = workSpace.OpenSolutionAsync(slnPath).Result; return(solution); }
/// <summary> /// This is where developed real job /// </summary> /// <param name="tfsVariables"></param> /// <param name="usrVariables"></param> /// <returns></returns> public abstract TaskStatu Job(TfsVariable tfsVariables, UserVariable <Tsetting> usrVariables);
private static List <UnitTestDetail> FindUnitTestReferences(Solution solution, IMethodSymbol method, TfsVariable tfsVariables) { var methodReferences = SymbolFinder.FindReferencesAsync(method, solution).Result.ToList(); if (!methodReferences.Any()) { return(null); } var depo = new List <UnitTestDetail>(); foreach (ReferencedSymbol methodReference in methodReferences) { IEnumerable <ReferenceLocation> locations = methodReference.Locations; foreach (ReferenceLocation location in locations) { MethodDeclarationSyntax referenceMds = GetMethodFromLine(location.Document.GetSemanticModelAsync().Result.SyntaxTree, location.Location.GetMappedLineSpan().StartLinePosition.Line); if (referenceMds != null) { ClassDeclarationSyntax referenceCds = referenceMds.Parent as ClassDeclarationSyntax; bool isTestClass = HasAttibute(referenceCds.AttributeLists, "TestClass"); if (isTestClass) { bool isTestMethod = HasAttibute(referenceMds.AttributeLists, "TestMethod"); if (isTestMethod) { string rightDll = FindRightOutputDll(location.Document.Project.OutputFilePath, tfsVariables); depo.Add( new UnitTestDetail(referenceMds.Identifier.Text, rightDll) ); } } } } } return(depo); }
private MethodUnitTestCollection GetChangeforChangedFiles(List <TFSFileState> changedFiles, TfsVariable tfsVariables, Solution solution) { var depo = new MethodUnitTestCollection(); if (!changedFiles.Any()) { return(depo); } foreach (var itmChanged in changedFiles) { var webPath = itmChanged.FilePath.Substring(1).Replace("/", "\\"); var serverVersion = TFSHelper.DownloadFile(webPath); serverVersion = string.IsNullOrEmpty(serverVersion) ? serverVersion : serverVersion.Replace("\r\n", "\n"); var localVersionFullPath = Path.Combine(tfsVariables.BuildSourceDirectory, webPath); var report = GetFileChanges(serverVersion, localVersionFullPath); Document doc = null; foreach (var tmp in solution.Projects) { doc = tmp.Documents.FirstOrDefault(x => x.FilePath == localVersionFullPath); if (doc != null) { break; } } if (doc == null) { WriteDetail(string.Format("(Changed) No project document found for : {0}", localVersionFullPath)); return(null); } var tmpMethods = GetChangedPublicMethods(doc, report); if (tmpMethods != null) { depo.Add(doc, tmpMethods); } } return(depo); }
private List <UnitTestDetail> CheckforUnitTest(PartialUnitTestSetting setting, Solution solution, TfsVariable tfsVariables, params MethodUnitTestCollection[] bags) { int totalFailCount = 0; List <UnitTestDetail> lst = new List <UnitTestDetail>(); foreach (var queuDepo in bags) { foreach (var itmDoc in queuDepo) { int tmpFail = 0; foreach (var itmMethod in itmDoc.Methods) { IMethodSymbol method = itmDoc.Doc.GetSemanticModelAsync().Result.GetDeclaredSymbol(itmMethod); var unitTest = FindUnitTestReferences(solution, method, tfsVariables); if ((unitTest == null) || !unitTest.Any()) { WriteDetail(string.Format("[{0}] method test is not found!!!", method.Name)); ++tmpFail; if (totalFailCount > setting.MaxLogCount) { return(null); } } else { lst.AddRange(unitTest); } } totalFailCount += tmpFail; if (tmpFail == 0) { WriteDetail(string.Format("[{0}] project's all test are found", itmDoc.Doc.Project.Name)); } } } return(totalFailCount == 0 ? lst : null); }
private MethodUnitTestCollection GetChangeforChangedAdded(List <TFSFileState> codesAdded, TfsVariable tfsVariables, Solution solution) { var depo = new MethodUnitTestCollection(); if (!codesAdded.Any()) { return(depo); } foreach (var itmChanged in codesAdded) { var webPath = itmChanged.FilePath.Replace("/", "\\").TrimStart('\\'); var localVersionFullPath = Path.Combine(tfsVariables.BuildSourceDirectory, webPath); Document doc = null; foreach (var tmp in solution.Projects) { doc = tmp.Documents.FirstOrDefault(x => x.FilePath == localVersionFullPath); if (doc != null) { break; } } if (doc == null) { WriteDetail(string.Format("(Added) No project document found for : {0}", localVersionFullPath)); return(null); } var tmpMethods = GetAllPublicMethods(doc); if (tmpMethods != null) { depo.Add(doc, tmpMethods); } } return(depo); }
public TFSBaseLogic(TfsVariable tfsVar) { initSetting = tfsVar; teamColl = new TfsTeamProjectCollection(new Uri(initSetting.CollectionUri)); }
public static bool Initialize(TfsVariable tfsVar) { initSetting = tfsVar; return(true); }
public override TaskStatu Job(TfsVariable tfsVariables, UserVariable <AnalyzerEnforcerSetting> usrVariables) { string settingOkMsg = CheckSetting(usrVariables); var setting = usrVariables.Config; if (!string.IsNullOrEmpty(settingOkMsg)) { return(new TaskStatu("RET01", settingOkMsg)); } string buildPath = tfsVariables.BuildSourceDirectory; string[] slnFiles = SolutionHelper.FindSolutionFiles(buildPath); slnFiles = !string.IsNullOrEmpty(tfsVariables.SolutiontoBuild) ? slnFiles.Where(x => x.Contains(tfsVariables.SolutiontoBuild)).ToArray() : slnFiles; if ((slnFiles == null) || (!slnFiles.Any())) { return(new TaskStatu("RET02", "No solution file found.")); } var workspace = MSBuildWorkspace.Create(); foreach (var slnItem in slnFiles) { var slnName = Path.GetFileNameWithoutExtension(slnItem); if (IsSolutionExcluded(setting, slnName)) { continue; } var solution = workspace.OpenSolutionAsync(slnItem).Result; foreach (var libItem in setting.References) { var analyzer = new AnalyzerFileReference(libItem.DLLPath, FromFileLoader.Instance); foreach (var project in solution.Projects) { if (IsProjectExcluded(setting, project.Name)) { continue; } bool analyzerExists = false; foreach (var analyzerReference in project.AnalyzerReferences) { if (analyzerReference.FullPath.EndsWith(libItem.DLLName)) { analyzerExists = true; break; } } if (!analyzerExists) { WriteDetail(string.Format("{0} project is missing {1} library. Adding...", project.Name, libItem.DLLName)); solution = solution.AddAnalyzerReference(project.Id, analyzer); } } } workspace.TryApplyChanges(solution); } return(new TaskStatu("Enforce finished successfully.")); }
public TFSApiLogic(TfsVariable tfsVar) : base(tfsVar) { SettingTFS = tfsVar; }
public override TaskStatu Job(TfsVariable tfsVariables, UserVariable <AutoDeploySetting> usrVariables) { var sourceFolder = tfsVariables.BuildDirectory; var setting = usrVariables?.Config; if (setting == null) { return(new TaskStatu("ADT01", "No setting loaded.")); } var inptControl = setting.CheckRules(); if (!string.IsNullOrEmpty(inptControl)) { return(new TaskStatu("ADT02", inptControl)); } if (setting.TakeBackup) { WriteDetail("Backup started."); var bckMsg = FileOperationHelper.TakeBackup(setting, sourceFolder, setting.BackupFolder); if (!string.IsNullOrEmpty(bckMsg)) { return(new TaskStatu("ADT03", bckMsg)); } WriteDetail("Backup finished."); } List <HashItem> fileHashInfo; List <string> srcFiles = PrepareFileList(sourceFolder, setting, out fileHashInfo); WriteDetail($"For deploy; {srcFiles.Count} files found."); bool willImpersonate = !string.IsNullOrEmpty(setting.ImpersonateName); bool willIISStopStart = !string.IsNullOrEmpty(setting.AppPoolName) && !string.IsNullOrEmpty(setting.IISServerName); var appMsg = StopIIS(willImpersonate, setting, willIISStopStart); if (!string.IsNullOrEmpty(appMsg)) { return(new TaskStatu("ADT04", appMsg)); } string deplMsg = StartDeploy(srcFiles, sourceFolder, setting); if (!string.IsNullOrEmpty(deplMsg)) { string rllMsg = StartRollBack(srcFiles, sourceFolder, setting); return(new TaskStatu("ADT05", deplMsg)); } string msgWrtHash = WriteNewHashFile(setting, fileHashInfo); var startMsg = StartIIS(willImpersonate, setting, willIISStopStart); if (!string.IsNullOrEmpty(startMsg)) { return(new TaskStatu("ADT06", startMsg)); } return(new TaskStatu("AutoDeploy finished successfully.")); }