protected override AzurePipelinesJob GetJob(
ExecutableTarget executableTarget,
LookupTable <ExecutableTarget, AzurePipelinesJob> jobs,
IReadOnlyCollection <ExecutableTarget> relevantTargets)
{
var job = base.GetJob(executableTarget, jobs, relevantTargets);
var symbol = CustomNames.GetValueOrDefault(job.Name).NotNull("symbol != null");
job.DisplayName = job.Parallel == 0
? $"{symbol} {job.DisplayName}"
: $"{symbol} {job.DisplayName} 🧩";
return(job);
}
protected override IEnumerable <TeamCityBuildType> GetBuildTypes(
NukeBuild build,
ExecutableTarget executableTarget,
TeamCityVcsRoot vcsRoot,
LookupTable <ExecutableTarget, TeamCityBuildType> buildTypes,
IReadOnlyCollection <ExecutableTarget> relevantTargets)
{
return(base.GetBuildTypes(build, executableTarget, vcsRoot, buildTypes, relevantTargets)
.ForEachLazy(x =>
{
var symbol = CustomNames.GetValueOrDefault(x.InvokedTargets.Last());
x.Name = (x.Partition == null
? $"{symbol} {x.Name}"
: $"{symbol} {x.InvokedTargets.Last()} 🧩 {x.Partition}").Trim();
}));
}
protected override AzurePipelinesJob GetJob(ExecutableTarget executableTarget, LookupTable <ExecutableTarget, AzurePipelinesJob> jobs)
{
var job = base.GetJob(executableTarget, jobs);
var dictionary = new Dictionary <string, string>
{
{ nameof(Compile), "⚙️" },
{ nameof(Pack), "📦" },
{ nameof(Publish), "🚚" }
};
var symbol = dictionary.GetValueOrDefault(job.Name).NotNull("symbol != null");
job.DisplayName = job.PartitionName == null
? $"{symbol} {job.DisplayName}"
: $"{symbol} {job.DisplayName} 🧩";
return(job);
}
protected virtual AzurePipelinesJob GetJob(
ExecutableTarget executableTarget,
LookupTable <ExecutableTarget, AzurePipelinesJob> jobs)
{
var(partitionName, totalPartitions) = ArtifactExtensions.Partitions.GetValueOrDefault(executableTarget.Definition);
var publishedArtifacts = ArtifactExtensions.ArtifactProducts[executableTarget.Definition]
.Select(x => (AbsolutePath)x)
.Select(x => x.DescendantsAndSelf(y => y.Parent).FirstOrDefault(y => !y.ToString().ContainsOrdinalIgnoreCase("*")))
.Distinct()
.Select(x => x.ToString().TrimStart(x.Parent.ToString()).TrimStart('/', '\\')).ToArray();
// var artifactDependencies = (
// from artifactDependency in ArtifactExtensions.ArtifactDependencies[executableTarget.Definition]
// let dependency = executableTarget.ExecutionDependencies.Single(x => x.Factory == artifactDependency.Item1)
// let rules = (artifactDependency.Item2.Any()
// ? artifactDependency.Item2
// : ArtifactExtensions.ArtifactProducts[dependency.Definition])
// .Select(GetArtifactRule).ToArray()
// select new TeamCityArtifactDependency
// {
// BuildType = buildTypes[dependency].Single(x => x.Partition == null),
// ArtifactRules = rules
// }).ToArray<TeamCityDependency>();
var invokedTargets = executableTarget
.DescendantsAndSelf(x => x.ExecutionDependencies, x => NonEntryTargets.Contains(x.Name))
.Where(x => x == executableTarget || NonEntryTargets.Contains(x.Name))
.Reverse()
.Select(x => x.Name).ToArray();
var dependencies = executableTarget.ExecutionDependencies
.Where(x => !ExcludedTargets.Contains(x.Name) && !NonEntryTargets.Contains(x.Name))
.SelectMany(x => jobs[x]).ToArray();
return(new AzurePipelinesJob
{
Name = executableTarget.Name,
DisplayName = executableTarget.Name,
ScriptPath = PowerShellScript,
Dependencies = dependencies,
Parallel = totalPartitions,
PartitionName = partitionName,
InvokedTargets = invokedTargets,
PublishArtifacts = publishedArtifacts
});
}
protected virtual IReadOnlyDictionary <string, JenkinsPipelineAgent> GetRegisteredJenkinsAgents(
IReadOnlyCollection <ExecutableTarget> relevantTargets)
{
var result = new Dictionary <string, JenkinsPipelineAgent>();
ExecutableTarget target = relevantTargets.FirstOrDefault();
if (target != null && target.Member != null && target.Member.DeclaringType != null)
{
Dictionary <string, JenkinsPipelineAgent> agents = target.Member.DeclaringType
.GetCustomAttributes <JenkinsAgentAttribute>()
.Select(GetRegisteredJenkinsAgent)
.ToDictionary(a => a.Label, a => a);
result.AddDictionary(agents);
}
return(new ReadOnlyDictionary <string, JenkinsPipelineAgent>(result));
}
protected IEnumerable <ExecutableTarget> GetInvokedTargets(ExecutableTarget executableTarget, IReadOnlyCollection <ExecutableTarget> relevantTargets)
{
var invokedTargets = new List <ExecutableTarget> {
executableTarget
};
ICollection <ExecutableTarget> additionalInvokedTargets;
do
{
additionalInvokedTargets = invokedTargets.SelectMany(x => x.ExecutionDependencies)
.Concat(invokedTargets.SelectMany(x => x.Triggers))
.Except(invokedTargets)
.Where(x => NonEntryTargets.Contains(x.Name))
.Where(x => !ExcludedTargets.Contains(x.Name)).ToList();
invokedTargets.AddRange(additionalInvokedTargets);
} while (additionalInvokedTargets.Count > 0);
return(ExecutionPlanner.GetExecutionPlan(invokedTargets, new[] { executableTarget.Name }));
}
protected IEnumerable <ExecutableTarget> GetInvokedTargets(ExecutableTarget executableTarget, IReadOnlyCollection <ExecutableTarget> relevantTargets)
{
var invokedTargets = new List <ExecutableTarget> {
executableTarget
};
ICollection <ExecutableTarget> additionalInvokedTargets;
do
{
additionalInvokedTargets = invokedTargets.SelectMany(x => x.ExecutionDependencies)
.Concat(invokedTargets.SelectMany(x => x.Triggers))
.Except(invokedTargets)
.Where(x => NonEntryTargets.Contains(x.Name))
.Where(x => !ExcludedTargets.Contains(x.Name)).ToList();
invokedTargets.AddRange(additionalInvokedTargets);
} while (additionalInvokedTargets.Count > 0);
Assert.True(invokedTargets.Except(new[] { executableTarget }).Count(x => x.PartitionSize != null) == 0,
$"Non-entry targets for {executableTarget.Name} cannot define partitions");
return(ExecutionPlanner.GetExecutionPlan(invokedTargets, new[] { executableTarget.Name }));
}
protected override AzurePipelinesJob GetJob(ExecutableTarget executableTarget,
LookupTable <ExecutableTarget, AzurePipelinesJob> jobs, IReadOnlyCollection <ExecutableTarget> relevantTargets)
{
var job = base.GetJob(executableTarget, jobs, relevantTargets);
var downloads = (
from pub in job.PublishArtifacts
select pub).ToArray();
return(new AuthenticatedPipelinesJob {
Name = job.Name,
DisplayName = job.DisplayName,
BuildCmdPath = job.BuildCmdPath,
Dependencies = job.Dependencies,
Parallel = job.Parallel,
PartitionName = job.PartitionName,
InvokedTargets = job.InvokedTargets,
PublishArtifacts = job.PublishArtifacts,
DownloadArtifacts = downloads
});
}
protected override AzurePipelinesJob GetJob(
ExecutableTarget executableTarget,
LookupTable<ExecutableTarget, AzurePipelinesJob> jobs,
IReadOnlyCollection<ExecutableTarget> relevantTargets)
{
var job = base.GetJob(executableTarget, jobs, relevantTargets);
var dictionary = new Dictionary<string, string>
{
{ nameof(Compile), "⚙️" },
{ nameof(Test), "🚦" },
{ nameof(Pack), "📦" },
{ nameof(Coverage), "📊" },
{ nameof(Publish), "🚚" },
{ nameof(Announce), "🗣" }
};
var symbol = dictionary.GetValueOrDefault(job.Name).NotNull("symbol != null");
job.DisplayName = job.PartitionName == null
? $"{symbol} {job.DisplayName}"
: $"{symbol} {job.DisplayName} 🧩";
return job;
}
protected override IEnumerable <TeamCityBuildType> GetBuildTypes(
NukeBuild build,
ExecutableTarget executableTarget,
TeamCityVcsRoot vcsRoot,
LookupTable <ExecutableTarget, TeamCityBuildType> buildTypes)
{
var dictionary = new Dictionary <string, string>
{
{ nameof(Compile), "⚙️" },
{ nameof(Test), "🚦" },
{ nameof(Publish), "🚚" }
};
return(base.GetBuildTypes(build, executableTarget, vcsRoot, buildTypes)
.ForEachLazy(x =>
{
var symbol = dictionary.GetValueOrDefault(x.InvokedTargets.Last()).NotNull("symbol != null");
x.Name = x.PartitionName == null
? $"{symbol} {x.Name}"
: $"{symbol} {x.InvokedTargets.Last()} 🧩 {x.Partition}";
}));
}
protected override AzurePipelinesJob GetJob(ExecutableTarget executableTarget,
LookupTable <ExecutableTarget, AzurePipelinesJob> jobs)
{
var job = base.GetJob(executableTarget, jobs);
var dictionary = new Dictionary <string, string>
{
{ nameof(Compile), "⚙️" },
{ nameof(CompileCoreOnly), "⚙️" },
{ nameof(Test), "🚦" },
{ nameof(TestCoreOnly), "🚦" },
{ nameof(Pack), "📦" },
{ nameof(PackCoreOnly), "📦" },
};
var symbol = dictionary.GetValueOrDefault(job.Name);
var prefix = symbol == null ? "" : $"{symbol} ";
job.DisplayName = job.PartitionName == null
? $"{prefix}{job.DisplayName}"
: $"{prefix}{job.DisplayName} 🧩";
return(job);
}
protected virtual AzurePipelinesStep GetStep(
ExecutableTarget executableTarget,
IReadOnlyCollection <ExecutableTarget> relevantTargets,
LookupTable <ExecutableTarget, AzurePipelinesStep> jobs
)
{
var chainLinkNames = GetInvokedTargets(executableTarget, relevantTargets).Select(z => z.Name).ToArray();
return(new AzurePipelinesStep
{
Name = executableTarget.Name,
DisplayName = GetStepName(executableTarget.Name),
ScriptPath = Path.ChangeExtension(
NukeBuild.RootDirectory.GlobFiles("build.ps1", "build.sh")
.Select(x => NukeBuild.RootDirectory.GetUnixRelativePathTo(x))
.FirstOrDefault()
.NotNull("Must have a build script of build.ps1 or build.sh"),
".ps1"
),
InvokedTargets = chainLinkNames,
});
}
protected override AzurePipelinesJob GetJob(ExecutableTarget executableTarget, LookupTable <ExecutableTarget, AzurePipelinesJob> jobs)
{
var job = base.GetJob(executableTarget, jobs);
var dictionary = new Dictionary <string, string>
{
{ nameof(Label), "🏷️" },
{ nameof(Clean), "🗑️" },
{ nameof(Restore), "⬇️" },
{ nameof(Compile), "⚙️" },
{ nameof(Pack), "📦" },
{ nameof(Test), "🚦" },
{ nameof(Report), "📄" },
{ nameof(Performance), "⏲️" },
};
var symbol = dictionary.GetValueOrDefault(job.Name).NotNull("symbol != null");
job.DisplayName = job.PartitionName == null
? $"{symbol} {job.DisplayName}"
: $"{symbol} {job.DisplayName} 🧩";
return(job);
}
protected virtual IEnumerable <ExecutableTarget> GetMatchedDependencies(
LookupTable <int, ExecutableTarget> groupedTargets,
IReadOnlyCollection <ExecutableTarget> allTargets,
ExecutableTarget target,
int slot)
{
var matchedDependencies = new List <ExecutableTarget>();
for (var i = 0; i < slot; i++)
{
IEnumerable <ExecutableTarget> allDependencies = target.ExecutionDependencies
.Union(target.AllDependencies.Intersect(allTargets));
foreach (ExecutableTarget dependency in allDependencies)
{
if (groupedTargets[i].Select(t => t.Name).Contains(dependency.Name))
{
matchedDependencies.Add(dependency);
}
}
}
return(matchedDependencies);
}
static string GetInformation(ExecutableTarget target)
=> target.SummaryInformation.Any()
? target.SummaryInformation.Select(x => $"{x.Key}: {x.Value}").JoinCommaSpace()
: null;
static string GetDurationOrBlank(ExecutableTarget target)
=> target.Status == ExecutionStatus.Succeeded ||
target.Status == ExecutionStatus.Failed ||
target.Status == ExecutionStatus.Aborted
? GetDuration(target.Duration)
: string.Empty;
protected virtual IEnumerable <TeamCityBuildType> GetBuildTypes(
NukeBuild build,
ExecutableTarget executableTarget,
TeamCityVcsRoot vcsRoot,
LookupTable <ExecutableTarget, TeamCityBuildType> buildTypes,
IReadOnlyCollection <ExecutableTarget> relevantTargets)
{
var chainLinkTargets = GetInvokedTargets(executableTarget, relevantTargets).ToArray();
var isPartitioned = ArtifactExtensions.Partitions.ContainsKey(executableTarget.Definition);
var artifactRules = chainLinkTargets.SelectMany(x =>
ArtifactExtensions.ArtifactProducts[x.Definition].Select(GetArtifactRule)).ToArray();
var artifactDependencies = chainLinkTargets.SelectMany(x =>
from artifactDependency in ArtifactExtensions.ArtifactDependencies[x.Definition]
let dependency = relevantTargets.Single(y => y.Factory == artifactDependency.Item1)
let rules = (artifactDependency.Item2.Any()
? artifactDependency.Item2
: ArtifactExtensions.ArtifactProducts[dependency.Definition])
.Select(GetArtifactRule).ToArray()
select new TeamCityArtifactDependency
{
BuildType = buildTypes[dependency].Single(y => y.Partition == null),
ArtifactRules = rules
}).ToArray <TeamCityDependency>();
var snapshotDependencies = GetTargetDependencies(executableTarget)
.SelectMany(x => buildTypes[x])
.Where(x => x.Partition == null)
.Select(x => new TeamCitySnapshotDependency
{
BuildType = x,
FailureAction = TeamCityDependencyFailureAction.FailToStart,
CancelAction = TeamCityDependencyFailureAction.Cancel
}).ToArray <TeamCityDependency>();
if (isPartitioned)
{
var(partitionName, totalPartitions) = ArtifactExtensions.Partitions[executableTarget.Definition];
for (var i = 0; i < totalPartitions; i++)
{
var partition = new Partition {
Part = i + 1, Total = totalPartitions
};
yield return(new TeamCityBuildType
{
Id = $"{executableTarget.Name}_P{partition.Part}T{partition.Total}",
Name = $"{executableTarget.Name} {partition}",
Description = executableTarget.Description,
BuildCmdPath = BuildCmdPath,
ArtifactRules = artifactRules,
Partition = partition,
PartitionName = partitionName,
InvokedTargets = chainLinkTargets.Select(x => x.Name).ToArray(),
VcsRoot = new TeamCityBuildTypeVcsRoot {
Root = vcsRoot, CleanCheckoutDirectory = CleanCheckoutDirectory
},
Dependencies = snapshotDependencies.Concat(artifactDependencies).ToArray()
});
}
artifactRules = new[] { "**/*" };
snapshotDependencies = buildTypes[executableTarget]
.Select(x => new TeamCitySnapshotDependency
{
BuildType = x,
FailureAction = TeamCityDependencyFailureAction.AddProblem,
CancelAction = TeamCityDependencyFailureAction.Cancel
}).ToArray <TeamCityDependency>();
artifactDependencies = buildTypes[executableTarget]
.Select(x => new TeamCityArtifactDependency
{
BuildType = x,
ArtifactRules = new[] { "**/*" }
}).ToArray <TeamCityDependency>();
}
var parameters = executableTarget.Requirements
.Where(x => !(x is Expression <Func <bool> >))
.Select(x => GetParameter(x.GetMemberInfo(), build, required: true))
.Concat(new TeamCityKeyValueParameter(
"teamcity.ui.runButton.caption",
executableTarget.Name.SplitCamelHumpsWithSeparator(" ", Constants.KnownWords))).ToArray();
var triggers = GetTriggers(executableTarget, buildTypes).ToArray();
yield return(new TeamCityBuildType
{
Id = executableTarget.Name,
Name = executableTarget.Name,
Description = executableTarget.Description,
BuildCmdPath = BuildCmdPath,
VcsRoot = new TeamCityBuildTypeVcsRoot
{
Root = vcsRoot,
ShowDependenciesChanges = isPartitioned,
CleanCheckoutDirectory = CleanCheckoutDirectory
},
IsComposite = isPartitioned,
IsDeployment = ManuallyTriggeredTargets.Contains(executableTarget.Name),
InvokedTargets = chainLinkTargets.Select(x => x.Name).ToArray(),
ArtifactRules = artifactRules,
Dependencies = snapshotDependencies.Concat(artifactDependencies).ToArray(),
Parameters = parameters,
Triggers = triggers
});
}
protected IEnumerable <ExecutableTarget> GetTargetDependencies(ExecutableTarget executableTarget)
{
return(executableTarget.ExecutionDependencies.Where(x => !IrrelevantTargetNames.Contains(x.Name)));
}
private void AddTrigger(ExecutableTarget source, ExecutableTarget target)
{
source.Triggers.Add(target);
target.TriggerDependencies.Add(source);
}
public static IEnumerable <string> GetArtifactProducts(this ExecutableTarget executableTarget)
{
return(ArtifactExtensionsAccessor.ArtifactProducts[executableTarget.GetDefinition()]);
}
public static ExecutableTarget ResolveExecutionDependency(
this ExecutableTarget executableTarget,
Target target)
{
return(executableTarget.ExecutionDependencies.Single(x => x.Factory == target));
}
protected virtual IEnumerable <TeamCityBuildType> GetBuildTypes(
NukeBuild build,
ExecutableTarget executableTarget,
TeamCityVcsRoot vcsRoot,
LookupTable <ExecutableTarget, TeamCityBuildType> buildTypes)
{
var isPartitioned = ArtifactExtensions.Partitions.ContainsKey(executableTarget.Definition);
var artifactRules = ArtifactExtensions.ArtifactProducts[executableTarget.Definition].Select(GetArtifactRule).ToArray();
var artifactDependencies = (
from artifactDependency in ArtifactExtensions.ArtifactDependencies[executableTarget.Definition]
let dependency = executableTarget.ExecutionDependencies.Single(x => x.Factory == artifactDependency.Item1)
let rules = (artifactDependency.Item2.Any()
? artifactDependency.Item2
: ArtifactExtensions.ArtifactProducts[dependency.Definition])
.Select(GetArtifactRule).ToArray()
select new TeamCityArtifactDependency
{
BuildType = buildTypes[dependency].Single(x => x.Partition == null),
ArtifactRules = rules
}).ToArray <TeamCityDependency>();
var invokedTargets = executableTarget
.DescendantsAndSelf(x => x.ExecutionDependencies, x => NonEntryTargets.Contains(x.Name))
.Where(x => x == executableTarget || NonEntryTargets.Contains(x.Name))
.Reverse()
.Select(x => x.Name).ToArray();
var snapshotDependencies = executableTarget.ExecutionDependencies
.Where(x => !ExcludedTargets.Contains(x.Name) && !NonEntryTargets.Contains(x.Name))
.SelectMany(x => buildTypes[x])
.Where(x => x.Partition == null)
.Select(x => new TeamCitySnapshotDependency
{
BuildType = x,
FailureAction = TeamCityDependencyFailureAction.FailToStart,
CancelAction = TeamCityDependencyFailureAction.Cancel
}).ToArray <TeamCityDependency>();
if (isPartitioned)
{
var partitions = ArtifactExtensions.Partitions[executableTarget.Definition];
for (var i = 0; i < partitions; i++)
{
var partition = new Partition {
Part = i + 1, Total = partitions
};
yield return(new TeamCityBuildType
{
Id = $"{executableTarget.Name}_P{partition.Part}T{partition.Total}",
Name = $"{executableTarget.Name} {partition}",
Description = executableTarget.Description,
Platform = Platform,
ArtifactRules = artifactRules,
Partition = partition,
PartitionTarget = executableTarget.Name,
InvokedTargets = invokedTargets,
VcsRoot = new TeamCityBuildTypeVcsRoot {
Root = vcsRoot
},
Dependencies = snapshotDependencies.Concat(artifactDependencies).ToArray()
});
}
snapshotDependencies = buildTypes[executableTarget]
.Select(x => new TeamCitySnapshotDependency
{
BuildType = x,
FailureAction = TeamCityDependencyFailureAction.FailToStart,
CancelAction = TeamCityDependencyFailureAction.Cancel
}).ToArray <TeamCityDependency>();
artifactDependencies = new TeamCityDependency[0];
}
var parameters = executableTarget.Requirements
.Where(x => !(x is Expression <Func <bool> >))
.Select(x => GetParameter(x.GetMemberInfo(), build, required: true)).ToArray();
var triggers = GetTriggers(executableTarget, buildTypes).ToArray();
yield return(new TeamCityBuildType
{
Id = executableTarget.Name,
Name = executableTarget.Name,
Description = executableTarget.Description,
Platform = Platform,
VcsRoot = new TeamCityBuildTypeVcsRoot
{
Root = vcsRoot,
ShowDependenciesChanges = isPartitioned
},
IsComposite = isPartitioned,
InvokedTargets = invokedTargets,
ArtifactRules = artifactRules,
Dependencies = snapshotDependencies.Concat(artifactDependencies).ToArray(),
Parameters = parameters,
Triggers = triggers
});
}
protected virtual AzurePipelinesJob GetJob(
ExecutableTarget executableTarget,
LookupTable <ExecutableTarget, AzurePipelinesJob> jobs)
{
var(partitionName, totalPartitions) = ArtifactExtensions.Partitions.GetValueOrDefault(executableTarget.Definition);
public static IEnumerable <string> GetAgents(this ExecutableTarget executableTarget)
{
return(Agents[executableTarget.GetDefinition()]);
}
