public void SetStepTarget(Pipelines.StepTarget target)
{
// Enforce command restriction if set for the step target
var commandManager = HostContext.GetService <IWorkerCommandManager>();
if (string.Equals(WellKnownStepTargetStrings.Restricted, target?.Commands, StringComparison.OrdinalIgnoreCase))
{
commandManager.SetCommandRestrictionPolicy(new AttributeBasedWorkerCommandRestrictionPolicy());
}
else
{
commandManager.SetCommandRestrictionPolicy(new UnrestricedWorkerCommandRestrictionPolicy());
}
// When step targets are set, we need to take over control for translating paths
// from the job execution context
Variables.StringTranslator = TranslatePathForStepTarget;
if (string.Equals(WellKnownStepTargetStrings.Host, target?.Target, StringComparison.OrdinalIgnoreCase))
{
_currentStepTarget = new HostInfo();
}
else
{
_currentStepTarget = Containers.FirstOrDefault(x => string.Equals(x.ContainerName, target?.Target, StringComparison.OrdinalIgnoreCase));
}
}
private IExecutionContext CreateTestExecutionContext(TestHostContext tc,
ExecutionTargetInfo stepTarget = null,
Dictionary <string, VariableValue> variables = null,
Dictionary <string, VariableValue> taskVariables = null)
{
var trace = tc.GetTrace();
var executionContext = new Mock <IExecutionContext>();
List <string> warnings;
variables = variables ?? new Dictionary <string, VariableValue>();
taskVariables = taskVariables ?? new Dictionary <string, VariableValue>();
executionContext
.Setup(x => x.Variables)
.Returns(new Variables(tc, copy: variables, warnings: out warnings));
executionContext
.Setup(x => x.TaskVariables)
.Returns(new Variables(tc, copy: taskVariables, warnings: out warnings));
if (stepTarget == null)
{
executionContext
.Setup(x => x.StepTarget())
.Returns(new HostInfo());
}
else
{
executionContext
.Setup(x => x.StepTarget())
.Returns(stepTarget);
}
return(executionContext.Object);
}
public void SetStepTarget(Pipelines.StepTarget target)
{
// When step targets are set, we need to take over control for translating paths
// from the job execution context
Variables.StringTranslator = TranslatePathForStepTarget;
if (string.Equals(WellKnownStepTargetStrings.Host, target?.Target, StringComparison.OrdinalIgnoreCase))
{
_currentStepTarget = new HostInfo();
}
else
{
_currentStepTarget = Containers.FirstOrDefault(x => string.Equals(x.ContainerName, target?.Target, StringComparison.OrdinalIgnoreCase));
}
}
public void InitializeJob(Pipelines.AgentJobRequestMessage message, CancellationToken token)
{
// Validation
Trace.Entering();
ArgUtil.NotNull(message, nameof(message));
ArgUtil.NotNull(message.Resources, nameof(message.Resources));
ArgUtil.NotNull(message.Variables, nameof(message.Variables));
ArgUtil.NotNull(message.Plan, nameof(message.Plan));
_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token);
// Features
Features = PlanUtil.GetFeatures(message.Plan);
// Endpoints
Endpoints = message.Resources.Endpoints;
// SecureFiles
SecureFiles = message.Resources.SecureFiles;
// Repositories
Repositories = message.Resources.Repositories;
// JobSettings
var checkouts = message.Steps?.Where(x => Pipelines.PipelineConstants.IsCheckoutTask(x)).ToList();
JobSettings = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
JobSettings[WellKnownJobSettings.HasMultipleCheckouts] = Boolean.FalseString;
if (checkouts != null && checkouts.Count > 0)
{
JobSettings[WellKnownJobSettings.HasMultipleCheckouts] = checkouts.Count > 1 ? Boolean.TrueString : Boolean.FalseString;
var firstCheckout = checkouts.First() as Pipelines.TaskStep;
if (firstCheckout != null && Repositories != null && firstCheckout.Inputs.TryGetValue(Pipelines.PipelineConstants.CheckoutTaskInputs.Repository, out string repoAlias))
{
JobSettings[WellKnownJobSettings.FirstRepositoryCheckedOut] = repoAlias;
var repo = Repositories.Find(r => String.Equals(r.Alias, repoAlias, StringComparison.OrdinalIgnoreCase));
if (repo != null)
{
repo.Properties.Set <bool>(RepositoryUtil.IsPrimaryRepository, true);
}
}
}
// Variables (constructor performs initial recursive expansion)
List <string> warnings;
Variables = new Variables(HostContext, message.Variables, out warnings);
Variables.StringTranslator = TranslatePathForStepTarget;
if (Variables.GetBoolean("agent.useWorkspaceId") == true)
{
try
{
// We need an identifier that represents which repos make up the workspace.
// This allows similar jobs in the same definition to reuse that workspace and other jobs to have their own.
JobSettings[WellKnownJobSettings.WorkspaceIdentifier] = GetWorkspaceIdentifier(message);
}
catch (Exception ex)
{
Trace.Warning($"Unable to generate workspace ID: {ex.Message}");
}
}
// Prepend Path
PrependPath = new List <string>();
// Docker (JobContainer)
string imageName = Variables.Get("_PREVIEW_VSTS_DOCKER_IMAGE");
if (string.IsNullOrEmpty(imageName))
{
imageName = Environment.GetEnvironmentVariable("_PREVIEW_VSTS_DOCKER_IMAGE");
}
Containers = new List <ContainerInfo>();
_defaultStepTarget = null;
_currentStepTarget = null;
if (!string.IsNullOrEmpty(imageName) &&
string.IsNullOrEmpty(message.JobContainer))
{
var dockerContainer = new Pipelines.ContainerResource()
{
Alias = "vsts_container_preview"
};
dockerContainer.Properties.Set("image", imageName);
var defaultJobContainer = HostContext.CreateContainerInfo(dockerContainer);
_defaultStepTarget = defaultJobContainer;
Containers.Add(defaultJobContainer);
}
else if (!string.IsNullOrEmpty(message.JobContainer))
{
var defaultJobContainer = HostContext.CreateContainerInfo(message.Resources.Containers.Single(x => string.Equals(x.Alias, message.JobContainer, StringComparison.OrdinalIgnoreCase)));
_defaultStepTarget = defaultJobContainer;
Containers.Add(defaultJobContainer);
}
else
{
_defaultStepTarget = new HostInfo();
}
// Include other step containers
var sidecarContainers = new HashSet <string>(message.JobSidecarContainers.Values, StringComparer.OrdinalIgnoreCase);
foreach (var container in message.Resources.Containers.Where(x =>
!string.Equals(x.Alias, message.JobContainer, StringComparison.OrdinalIgnoreCase) && !sidecarContainers.Contains(x.Alias)))
{
Containers.Add(HostContext.CreateContainerInfo(container));
}
// Docker (Sidecar Containers)
SidecarContainers = new List <ContainerInfo>();
foreach (var sidecar in message.JobSidecarContainers)
{
var networkAlias = sidecar.Key;
var containerResourceAlias = sidecar.Value;
var containerResource = message.Resources.Containers.Single(c => string.Equals(c.Alias, containerResourceAlias, StringComparison.OrdinalIgnoreCase));
ContainerInfo containerInfo = HostContext.CreateContainerInfo(containerResource, isJobContainer: false);
containerInfo.ContainerNetworkAlias = networkAlias;
SidecarContainers.Add(containerInfo);
}
// Proxy variables
var agentWebProxy = HostContext.GetService <IVstsAgentWebProxy>();
if (!string.IsNullOrEmpty(agentWebProxy.ProxyAddress))
{
Variables.Set(Constants.Variables.Agent.ProxyUrl, agentWebProxy.ProxyAddress);
Environment.SetEnvironmentVariable("VSTS_HTTP_PROXY", string.Empty);
if (!string.IsNullOrEmpty(agentWebProxy.ProxyUsername))
{
Variables.Set(Constants.Variables.Agent.ProxyUsername, agentWebProxy.ProxyUsername);
Environment.SetEnvironmentVariable("VSTS_HTTP_PROXY_USERNAME", string.Empty);
}
if (!string.IsNullOrEmpty(agentWebProxy.ProxyPassword))
{
Variables.Set(Constants.Variables.Agent.ProxyPassword, agentWebProxy.ProxyPassword, true);
Environment.SetEnvironmentVariable("VSTS_HTTP_PROXY_PASSWORD", string.Empty);
}
if (agentWebProxy.ProxyBypassList.Count > 0)
{
Variables.Set(Constants.Variables.Agent.ProxyBypassList, JsonUtility.ToString(agentWebProxy.ProxyBypassList));
}
}
// Certificate variables
var agentCert = HostContext.GetService <IAgentCertificateManager>();
if (agentCert.SkipServerCertificateValidation)
{
Variables.Set(Constants.Variables.Agent.SslSkipCertValidation, bool.TrueString);
}
if (!string.IsNullOrEmpty(agentCert.CACertificateFile))
{
Variables.Set(Constants.Variables.Agent.SslCAInfo, agentCert.CACertificateFile);
}
if (!string.IsNullOrEmpty(agentCert.ClientCertificateFile) &&
!string.IsNullOrEmpty(agentCert.ClientCertificatePrivateKeyFile) &&
!string.IsNullOrEmpty(agentCert.ClientCertificateArchiveFile))
{
Variables.Set(Constants.Variables.Agent.SslClientCert, agentCert.ClientCertificateFile);
Variables.Set(Constants.Variables.Agent.SslClientCertKey, agentCert.ClientCertificatePrivateKeyFile);
Variables.Set(Constants.Variables.Agent.SslClientCertArchive, agentCert.ClientCertificateArchiveFile);
if (!string.IsNullOrEmpty(agentCert.ClientCertificatePassword))
{
Variables.Set(Constants.Variables.Agent.SslClientCertPassword, agentCert.ClientCertificatePassword, true);
}
}
// Runtime option variables
var runtimeOptions = HostContext.GetService <IConfigurationStore>().GetAgentRuntimeOptions();
if (runtimeOptions != null)
{
if (PlatformUtil.RunningOnWindows && runtimeOptions.GitUseSecureChannel)
{
Variables.Set(Constants.Variables.Agent.GitUseSChannel, runtimeOptions.GitUseSecureChannel.ToString());
}
}
// Job timeline record.
InitializeTimelineRecord(
timelineId: message.Timeline.Id,
timelineRecordId: message.JobId,
parentTimelineRecordId: null,
recordType: ExecutionContextType.Job,
displayName: message.JobDisplayName,
refName: message.JobName,
order: null); // The job timeline record's order is set by server.
// Logger (must be initialized before writing warnings).
_logger = HostContext.CreateService <IPagingLogger>();
_logger.Setup(_mainTimelineId, _record.Id);
// Log warnings from recursive variable expansion.
warnings?.ForEach(x => this.Warning(x));
// Verbosity (from system.debug).
WriteDebug = Variables.System_Debug ?? false;
// Hook up JobServerQueueThrottling event, we will log warning on server tarpit.
_jobServerQueue.JobServerQueueThrottling += JobServerQueueThrottling_EventReceived;
}
