public static async Task <CodeCheckResult> CheckForNeededBuild(this BuildProjectConfiguration config, ICodeRepository code, BuildQueueEntry latestBuild)
{
var maxFailureCount = config.MaxFailureCount;
var force = false;
var codeInfo = await code.GetInfo(config.RepositoryPath);
string currentCommitIdentifier = codeInfo?.RevisionIdentifier;
if (force || latestBuild == null)
{
return(CodeCheckResult.Force(currentCommitIdentifier));
}
else if (currentCommitIdentifier.Equals(latestBuild.RevisionIdentifier))
{
return(CodeCheckResult.Skip());
}
else if (latestBuild.FailCount > maxFailureCount)
{
return(CodeCheckResult.Skip());
}
else
{
var changedFiles = await code.GetChangedFiles(config.RepositoryPath, latestBuild?.RevisionIdentifier, currentCommitIdentifier);
if (changedFiles.Count() <= 0)
{
//reason = $"The build was skipped because no files in the latest commit matched the effective change filter.";
// continue to the next build
return(CodeCheckResult.Skip());
}
return(CodeCheckResult.Changed(currentCommitIdentifier));
}
}
public static ICodeRepository Create(BuildProjectConfiguration project)
{
if (project.RepositoryType.Equals("svn", StringComparison.OrdinalIgnoreCase))
{
return(new SteadyBuild.Extensions.Svn.SvnCodeRepository(project));
}
else
{
throw new NotSupportedException($"There is no provided for the repository type '{project.RepositoryType}'.");
}
}
public DbProjectRecord(BuildProjectConfiguration project)
{
this.Name = project.Name;
this.ProjectID = project.ProjectID;
this.RepositoryType = project.RepositoryType;
this.RepositoryPath = project.RepositoryPath;
this.MaxFailureCount = project.MaxFailureCount;
this.NotifyTheAuthor = project.NotifyTheAuthor;
this.BlameTheAuthor = project.BlameTheAuthor;
this.MaxFailureCount = project.MaxFailureCount;
this.IsActive = project.IsActive;
}
public void TestSvnGetDiff()
{
var project = new BuildProjectConfiguration();
var svn = new SteadyBuild.Extensions.Svn.SvnCodeRepository(project);
project.RepositoryPath = REPO_PATH;
var changedFiles = svn.GetChangedFiles(REPO_PATH, "110", "112").Result;
Assert.IsNotNull(changedFiles);
Assert.AreEqual(61, changedFiles.Count());
}
public SvnCodeRepository(string exePath, BuildProjectConfiguration project)
{
_project = project;
if (exePath == null)
{
_exePath = "svn.exe";
}
else
{
_exePath = System.IO.Path.Combine(exePath, "svn.exe");
}
}
public void TestSvnGetInfo()
{
var project = new BuildProjectConfiguration();
var svn = new SteadyBuild.Extensions.Svn.SvnCodeRepository(project);
project.RepositoryPath = REPO_PATH;
var svnInfo = svn.GetInfo(REPO_PATH, "112").Result;
Assert.IsNotNull(svnInfo);
Assert.AreEqual("langer", svnInfo.Author);
Assert.AreEqual("112", svnInfo.RevisionIdentifier);
}
public async Task UpdateProjectAsync(BuildProjectConfiguration project)
{
this.EnsureOpenConnection();
var projectData = new DbProjectRecord(project);
using (var transaction = this.Connection.BeginTransaction())
{
await this.Connection.UpdateAsync(projectData, transaction);
if (project.Contacts == null || project.Contacts.Count == 0)
{
await this.Connection.ExecuteAsync("DELETE FROM ProjectContact WHERE ProjectID=@ProjectID", transaction : transaction, param : new
{
ProjectID = project.ProjectID
});
}
transaction.Commit();
}
}
public async Task AddProjectAsync(BuildProjectConfiguration project)
{
this.EnsureOpenConnection();
var projectData = new DbProjectRecord(project);
using (var transaction = this.Connection.BeginTransaction())
{
await this.Connection.InsertAsync(projectData, transaction);
if (project.Contacts != null && project.Contacts.Count() > 0)
{
foreach (var contact in project.Contacts)
{
await this.Connection.InsertAsync(new DbProjectContactRecord(projectData.ProjectID, contact), transaction);
}
}
if (project.AssetPaths != null && project.AssetPaths.Count() > 0)
{
foreach (var asset in project.AssetPaths)
{
await this.Connection.InsertAsync(new DbProjectAssetRecord(projectData.ProjectID, asset), transaction);
}
}
if (project.RepositorySettings != null)
{
foreach (var keyPair in project.RepositorySettings)
{
await this.Connection.InsertAsync(new DbProjectSettingRecord()
{
ProjectID = projectData.ProjectID,
TypeName = "Repository",
Name = keyPair.Key,
Value = keyPair.Value
}, transaction);
}
}
if (project.Variables != null)
{
foreach (var keyPair in project.Variables)
{
await this.Connection.InsertAsync(new DbProjectSettingRecord()
{
ProjectID = projectData.ProjectID,
TypeName = "Variable",
Name = keyPair.Key,
Value = keyPair.Value
}, transaction);
}
}
if (project.Tasks != null)
{
for (int taskNo = 1; taskNo <= project.Tasks.Count; taskNo++)
{
await this.Connection.InsertAsync(new DbProjectTaskRecord(projectData.ProjectID, project.Tasks[taskNo - 1], taskNo));
}
}
transaction.Commit();
}
}
public async Task <BuildProjectConfiguration> GetProject(Guid projectIdentifier)
{
this.EnsureOpenConnection();
var param = new
{
ProjectID = projectIdentifier
};
var commandText = new StringBuilder();
commandText.AppendLine("SELECT * FROM Project WHERE ProjectID = @ProjectID;");
commandText.AppendLine("SELECT * FROM ProjectContact WHERE ProjectID = @ProjectID;");
commandText.AppendLine("SELECT * FROM ProjectTask WHERE ProjectID = @ProjectID ORDER BY TaskNumber;");
commandText.AppendLine("SELECT * FROM ProjectAsset WHERE ProjectID = @ProjectID ORDER BY [Path];");
commandText.AppendLine("SELECT * FROM ProjectSetting WHERE ProjectID = @ProjectID ORDER BY [TypeName]");
var result = await this.Connection.QueryMultipleAsync(commandText.ToString(), param : param);
var project = result.ReadSingle <DbProjectRecord>();
var contacts = result.Read <DbProjectContactRecord>();
var tasks = result.Read <DbProjectTaskRecord>();
var assets = result.Read <DbProjectAssetRecord>();
var settings = result.Read <DbProjectSettingRecord>();
var bp = new BuildProjectConfiguration();
bp.ProjectID = project.ProjectID;
bp.Name = project.Name;
bp.IsActive = project.IsActive;
bp.EnvironmentID = project.EnvironmentID;
bp.NotifyTheAuthor = project.NotifyTheAuthor;
bp.PraiseTheAuthor = project.PraiseTheAuthor;
bp.RepositoryPath = project.RepositoryPath;
bp.RepositoryType = project.RepositoryType;
bp.MaxFailureCount = project.MaxFailureCount;
bp.AssetPaths = assets.Select(s => s.Path);
bp.Contacts = new List <BuildProjectContact>(contacts.Select(s => new BuildProjectContact()
{
Name = s.Name,
Email = s.Email,
Phone = s.Phone,
NotifyOnFailure = s.NotifyOnFailure,
NotifyOnSuccess = s.NotifyOnSuccess,
RepositoryUsername = s.RepositoryUsername,
ProjectContactID = s.ProjectContactID
}));
bp.RepositorySettings = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
bp.Variables = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var setting in settings)
{
if (setting.TypeName == "Repository")
{
bp.RepositorySettings.Add(setting.Name, setting.Value);
}
else if (setting.TypeName == "Variable")
{
bp.Variables.Add(setting.Name, setting.Value);
}
else
{
throw new NotSupportedException($"An unsupported setting type {setting.TypeName} was detected.");
}
}
bp.Tasks = new List <BuildTask>(tasks.Select(s => new BuildTask(s.Expression)
{
SuccessfulExitCodes = s.SuccessExitCodes.Split(',').Select(c => int.Parse(c)),
}));
return(bp);
}
public void TestStartProcessCreatesEnvironmentVariables()
{
var writer = new Mock.MockBuildOutputWriter()
{
PrefixSeverity = false
};
var agentOptions = new BuildAgentOptions()
{
AgentIdentifier = "AgentID",
ConcurrentBuilds = 1,
WorkingPath = "WorkingPath"
};
var codeInfo = new CodeRepositoryInfo()
{
Author = "Author",
RevisionIdentifier = "RevIdent"
};
var buildEntry = new BuildQueueEntry()
{
BuildNumber = 999
};
var project = new BuildProjectConfiguration()
{
ProjectID = Guid.NewGuid(),
Name = "TestProject",
RepositoryType = "svn",
RepositoryPath = "repo-path",
Variables = new Dictionary <string, string>()
{
{ "VarTest", "123" }
}
};
using (var env = new BuildEnvironment("C:\\Build", writer))
{
env.AddAgentVariables(agentOptions);
env.AddCodeInfoVariables(codeInfo);
env.AddGlobalVariables();
env.AddQueueEntryVariables(buildEntry);
env.AddProjectConfigurationVariables(project);
var resultCode = env.StartProcessAsync("cmd.exe", "/c set").Result;
Assert.AreEqual(0, resultCode);
}
var vars = new Dictionary <string, string>();
using (var reader = new System.IO.StringReader(writer.StringWriter.ToString()))
{
string line;
while (true)
{
line = reader.ReadLine();
if (line == null)
{
break;
}
var parts = line.Split(new char[] { '=' }, 2);
vars.Add(parts[0], parts[1]);
}
}
Assert.AreEqual("true", vars["CI"]);
Assert.AreEqual("C:\\Build", vars["CI_WORKINGPATH"]);
Assert.AreEqual(Environment.MachineName, vars["CI_AGENTHOST"]);
Assert.AreEqual(agentOptions.AgentIdentifier, vars["CI_AGENTIDENTIFIER"]);
Assert.AreEqual(codeInfo.RevisionIdentifier, vars["CI_REVISIONIDENTIFIER"]);
Assert.AreEqual(codeInfo.Author, vars["CI_REVISIONAUTHOR"]);
Assert.IsNotNull(vars["CI_BUILDDATE"]);
Assert.IsNotNull(vars["CI_BUILDDATETIME"]);
Assert.AreEqual(project.NextBuildNumber, int.Parse(vars["CI_BUILDNUMBER"]));
Assert.AreEqual(project.ProjectID.ToString(), vars["CI_PROJECTID"]);
Assert.AreEqual(project.Name, vars["CI_PROJECTNAME"]);
Assert.AreEqual(project.RepositoryType, vars["CI_REPOSITORYTYPE"]);
Assert.AreEqual(project.RepositoryPath, vars["CI_REPOSITORYPATH"]);
Assert.AreEqual(project.Variables["VarTest"], vars["CI_VARTEST"]);
}
public SvnCodeRepository(BuildProjectConfiguration project) : this(null, project)
{
}
