/// <summary>
/// Initializes a build request with a parent context.
/// </summary>
/// <param name="submissionId">The id of the build submission.</param>
/// <param name="nodeRequestId">The id of the node issuing the request</param>
/// <param name="configurationId">The configuration id to use.</param>
/// <param name="escapedTargets">The targets to be built</param>
/// <param name="hostServices">Host services if any. May be null.</param>
/// <param name="parentBuildEventContext">The build event context of the parent project.</param>
/// <param name="parentRequest">The parent build request, if any.</param>
/// <param name="skipStaticGraphIsolationConstraints"></param>
/// <param name="buildRequestDataFlags">Additional flags for the request.</param>
/// <param name="requestedProjectState">Filter for desired build results.</param>
public BuildRequest(
int submissionId,
int nodeRequestId,
int configurationId,
ICollection <string> escapedTargets,
HostServices hostServices,
BuildEventContext parentBuildEventContext,
BuildRequest parentRequest,
BuildRequestDataFlags buildRequestDataFlags = BuildRequestDataFlags.None,
RequestedProjectState requestedProjectState = null,
bool skipStaticGraphIsolationConstraints = false)
{
ErrorUtilities.VerifyThrowArgumentNull(escapedTargets, "targets");
ErrorUtilities.VerifyThrowArgumentNull(parentBuildEventContext, "parentBuildEventContext");
_submissionId = submissionId;
_configurationId = configurationId;
// When targets come into a build request, we unescape them.
_targets = new List <string>(escapedTargets.Count);
foreach (string target in escapedTargets)
{
_targets.Add(EscapingUtilities.UnescapeAll(target));
}
HostServices = hostServices;
_buildEventContext = BuildEventContext.Invalid;
_parentBuildEventContext = parentBuildEventContext;
_globalRequestId = InvalidGlobalRequestId;
_parentGlobalRequestId = parentRequest?.GlobalRequestId ?? InvalidGlobalRequestId;
_nodeRequestId = nodeRequestId;
_buildRequestDataFlags = buildRequestDataFlags;
_requestedProjectState = requestedProjectState;
_skipStaticGraphIsolationConstraints = skipStaticGraphIsolationConstraints;
}
/// <summary>
/// Constructor.
/// </summary>
public SchedulerCircularDependencyException(BuildRequest request, IList <SchedulableRequest> ancestors)
{
_request = request;
_ancestors = ancestors;
}
/// <summary>
/// Constructor over a request.
/// </summary>
public BlockingRequestKey(BuildRequest request)
{
_globalRequestId = request.GlobalRequestId;
_nodeRequestId = request.NodeRequestId;
}
/// <summary>
/// Constructor for the unblocker for circular dependencies
/// </summary>
internal BuildRequestUnblocker(BuildRequest parentRequest, BuildResult buildResult)
: this(buildResult)
{
ErrorUtilities.VerifyThrowArgumentNull(parentRequest, nameof(parentRequest));
_blockedGlobalRequestId = parentRequest.GlobalRequestId;
}
/// <summary>
/// Handles the BuildRequest packet.
/// </summary>
private void HandleBuildRequest(BuildRequest request)
{
_buildRequestEngine.SubmitBuildRequest(request);
}
/// <summary>
/// Creates a CircularDependency response.
/// </summary>
/// <param name="node">The node to which the response should be sent.</param>
/// <param name="parentRequest">The request which attempted to invoke the request causing the circular dependency.</param>
/// <param name="requestCausingCircularDependency">The request which caused the circular dependency.</param>
/// <returns>The ScheduleResponse.</returns>
public static ScheduleResponse CreateCircularDependencyResponse(int node, BuildRequest parentRequest, BuildRequest requestCausingCircularDependency)
{
return(new ScheduleResponse(node, parentRequest, requestCausingCircularDependency));
}
/// <summary>
/// Creates a Schedule or ScheduleWithConfiguration response
/// </summary>
/// <param name="node">The node to which the response should be sent.</param>
/// <param name="requestToSchedule">The request to be scheduled.</param>
/// <param name="sendConfiguration">Flag indicating whether or not the configuration for the request must be sent to the node as well.</param>
/// <returns>The ScheduleResponse.</returns>
public static ScheduleResponse CreateScheduleResponse(int node, BuildRequest requestToSchedule, bool sendConfiguration)
{
return(new ScheduleResponse(node, requestToSchedule, sendConfiguration));
}
/// <summary>
/// Constructs a response where a request should be scheduled.
/// </summary>
/// <param name="node">The node ID to which the request should be sent.</param>
/// <param name="request">The request to send.</param>
/// <param name="sendConfiguration"><code>true</code> to send the configuration, otherwise <code>false</code>.</param>
private ScheduleResponse(int node, BuildRequest request, bool sendConfiguration)
{
Action = sendConfiguration ? ScheduleActionType.ScheduleWithConfiguration : ScheduleActionType.Schedule;
NodeId = node;
BuildRequest = request;
}
/// <summary>
/// Attempts to satisfy the request from the cache. The request can be satisfied only if:
/// 1. All specified targets in the request have successful results in the cache or if the sequence of target results
/// includes 0 or more successful targets followed by at least one failed target.
/// 2. All initial targets in the configuration for the request have non-skipped results in the cache.
/// 3. If there are no specified targets, then all default targets in the request must have non-skipped results
/// in the cache.
/// </summary>
/// <param name="request">The request whose results we should return</param>
/// <param name="configInitialTargets">The initial targets for the request's configuration.</param>
/// <param name="configDefaultTargets">The default targets for the request's configuration.</param>
/// <param name="skippedResultsDoNotCauseCacheMiss">If false, a cached skipped target will cause this method to return "NotSatisfied".
/// If true, then as long as there is a result in the cache (regardless of whether it was skipped or not), this method
/// will return "Satisfied". In most cases this should be false, but it may be set to true in a situation where there is no
/// chance of re-execution (which is the usual response to missing / skipped targets), and the caller just needs the data.</param>
/// <returns>A response indicating the results, if any, and the targets needing to be built, if any.</returns>
public ResultsCacheResponse SatisfyRequest(BuildRequest request, List <string> configInitialTargets, List <string> configDefaultTargets, bool skippedResultsDoNotCauseCacheMiss)
{
ErrorUtilities.VerifyThrowArgument(request.IsConfigurationResolved, "UnresolvedConfigurationInRequest");
ResultsCacheResponse response = new ResultsCacheResponse(ResultsCacheResponseType.NotSatisfied);
lock (_resultsByConfiguration)
{
if (_resultsByConfiguration.ContainsKey(request.ConfigurationId))
{
BuildResult allResults = _resultsByConfiguration[request.ConfigurationId];
// Check for targets explicitly specified.
bool explicitTargetsSatisfied = CheckResults(allResults, request.Targets, response.ExplicitTargetsToBuild, skippedResultsDoNotCauseCacheMiss);
if (explicitTargetsSatisfied)
{
// All of the explicit targets, if any, have been satisfied
response.Type = ResultsCacheResponseType.Satisfied;
// Check for the initial targets. If we don't know what the initial targets are, we assume they are not satisfied.
if (configInitialTargets == null || !CheckResults(allResults, configInitialTargets, null, skippedResultsDoNotCauseCacheMiss))
{
response.Type = ResultsCacheResponseType.NotSatisfied;
}
// We could still be missing implicit targets, so check those...
if (request.Targets.Count == 0)
{
// Check for the default target, if necessary. If we don't know what the default targets are, we
// assume they are not satisfied.
if (configDefaultTargets == null || !CheckResults(allResults, configDefaultTargets, null, skippedResultsDoNotCauseCacheMiss))
{
response.Type = ResultsCacheResponseType.NotSatisfied;
}
}
// Now report those results requested, if they are satisfied.
if (response.Type == ResultsCacheResponseType.Satisfied)
{
List <string> targetsToAddResultsFor = new List <string>(configInitialTargets);
// Now report either the explicit targets or the default targets
if (request.Targets.Count > 0)
{
targetsToAddResultsFor.AddRange(request.Targets);
}
else
{
targetsToAddResultsFor.AddRange(configDefaultTargets);
}
response.Results = new BuildResult(request, allResults, targetsToAddResultsFor.ToArray(), null);
}
}
else
{
// Some targets were not satisfied.
response.Type = ResultsCacheResponseType.NotSatisfied;
}
}
}
return(response);
}