/// <summary>
/// If supported, convert the provided value into a <see cref="IPropertyToken"/>.
/// </summary>
/// <param name="converter">Converter for conversion of additional values.</param>
/// <param name="value">The value to convert.</param>
/// <param name="result">Value converted to <see cref="IPropertyToken"/> if conversion was successful.</param>
/// <returns><c>true</c> if the value could be converted under this policy; <c>false</c> otherwise.</returns>
public bool TryConvert(IPropertyConverter converter, object value, out IPropertyToken result)
{
result = null;
if (converter == null)
{
throw new ArgumentNullException(nameof(converter));
}
var enumerable = value as IEnumerable;
if (enumerable == null)
{
return(false);
}
if (value.GetType().IsDictionary())
{
return(false);
}
var elements = enumerable.Cast <object>();
if (_config.ItemLimit > 0)
{
elements = elements.Take(_config.ItemLimit);
}
result = new SequenceToken(elements.Select(converter.Convert));
return(true);
}
public static ArrayContextData ToContextData(this SequenceToken sequence)
{
var token = sequence as TemplateToken;
var contextData = token.ToContextData();
return(contextData.AssertArray("converted sequence token"));
}
internal Boolean AllowSequenceStart(
Boolean expand,
out SequenceToken sequence)
{
m_memory.IncrementEvents();
if (expand)
{
Unravel(expand: true);
}
if (m_current is SequenceState sequenceState && sequenceState.IsStart)
{
sequence = new SequenceToken(sequenceState.Value.FileId, sequenceState.Value.Line, sequenceState.Value.Column);
// Add bytes before they are emitted to the caller (so the caller doesn't have to track bytes)
m_memory.AddBytes(sequence);
MoveNext();
return(true);
}
sequence = null;
return(false);
}
public void Evaluate_ContainerAction_Args()
{
try
{
//Arrange
Setup();
var actionManifest = new ActionManifestManager();
actionManifest.Initialize(_hc);
var arguments = new SequenceToken(null, null, null);
arguments.Add(new BasicExpressionToken(null, null, null, "inputs.greeting"));
arguments.Add(new StringToken(null, null, null, "test"));
var inputsContext = new DictionaryContextData();
inputsContext.Add("greeting", new StringContextData("hello"));
var evaluateContext = new Dictionary <string, PipelineContextData>(StringComparer.OrdinalIgnoreCase);
evaluateContext["inputs"] = inputsContext;
//Act
var result = actionManifest.EvaluateContainerArguments(_ec.Object, arguments, evaluateContext);
//Assert
Assert.Equal("hello", result[0]);
Assert.Equal("test", result[1]);
Assert.Equal(2, result.Count);
}
finally
{
Teardown();
}
}
public void Write(StringBuilder builder, SequenceToken sequence)
{
if (builder == null || sequence == null)
{
return;
}
builder.Append(SequenceToken.Keyword);
}
public ILexicalElementable EnsureStartToken()
{
if (SequenceStartToken == null)
{
SequenceStartToken = new SequenceToken();
}
return(SequenceStartToken);
}
public void SequenceToken_TokenSequence_SequenceContainsInputElements()
{
var elements = Enumerable.Range(0, 3).Select(v => new ScalarToken(v)).ToList();
var sequence = new SequenceToken(elements);
Assert.Equal(3, sequence.Elements.Count);
Assert.True(sequence.Elements.SequenceEqual(elements));
}
// todo: remove after feature-flag DistributedTask.EvaluateContainerOnRunner is enabled everywhere
internal static TemplateToken ConvertToTemplateToken(ContainerResource resource)
{
var result = new MappingToken(null, null, null);
var image = resource.Image;
if (!string.IsNullOrEmpty(image))
{
result.Add(new StringToken(null, null, null, "image"), new StringToken(null, null, null, image));
}
var options = resource.Options;
if (!string.IsNullOrEmpty(options))
{
result.Add(new StringToken(null, null, null, "options"), new StringToken(null, null, null, options));
}
var environment = resource.Environment;
if (environment?.Count > 0)
{
var mapping = new MappingToken(null, null, null);
foreach (var pair in environment)
{
mapping.Add(new StringToken(null, null, null, pair.Key), new StringToken(null, null, null, pair.Value));
}
result.Add(new StringToken(null, null, null, "env"), mapping);
}
var ports = resource.Ports;
if (ports?.Count > 0)
{
var sequence = new SequenceToken(null, null, null);
foreach (var item in ports)
{
sequence.Add(new StringToken(null, null, null, item));
}
result.Add(new StringToken(null, null, null, "ports"), sequence);
}
var volumes = resource.Volumes;
if (volumes?.Count > 0)
{
var sequence = new SequenceToken(null, null, null);
foreach (var item in volumes)
{
sequence.Add(new StringToken(null, null, null, item));
}
result.Add(new StringToken(null, null, null, "volumes"), sequence);
}
return(result);
}
public void Format_EmptySequenceToken_IsFormattedAsArray()
{
var output = new StringWriter();
var formater = new JsonPropertyFormatter(output);
var token = new SequenceToken(null);
token.Render(formater);
Assert.Equal("[]", output.ToString());
}
public void Format_NonEmptySequenceToken_IsFormattedAsArray()
{
var output = new StringWriter();
var formater = new JsonPropertyFormatter(output);
var token = new SequenceToken(new[] { new ScalarToken(1), new ScalarToken("foo") });
token.Render(formater);
Assert.Equal("[1, \"foo\"]", output.ToString());
}
public void Render_SomeFormatter_FormatterIsCalled()
{
var formatterMock = new Mock <IPropertyFormatter>();
var formatter = formatterMock.Object;
var sequence = new SequenceToken(null);
sequence.Render(formatter);
formatterMock.Verify(m => m.Format(sequence), Times.Once);
}
public Boolean AllowSequenceStart(out SequenceToken value)
{
if (EvaluateCurrent() is SequenceStart sequenceStart)
{
value = new SequenceToken(m_fileId, sequenceStart.Start.Line, sequenceStart.Start.Column);
MoveNext();
return(true);
}
value = default;
return(false);
}
internal static TemplateToken ToTemplateToken(this PipelineContextData data)
{
if (data is null)
{
return(new NullToken(null, null, null));
}
switch (data.Type)
{
case PipelineContextDataType.Dictionary:
var dictionary = data.AssertDictionary("dictionary");
var mapping = new MappingToken(null, null, null);
if (dictionary.Count > 0)
{
foreach (var pair in dictionary)
{
var key = new StringToken(null, null, null, pair.Key);
var value = pair.Value.ToTemplateToken();
mapping.Add(key, value);
}
}
return(mapping);
case PipelineContextDataType.Array:
var array = data.AssertArray("array");
var sequence = new SequenceToken(null, null, null);
if (array.Count > 0)
{
foreach (var item in array)
{
sequence.Add(item.ToTemplateToken());
}
}
return(sequence);
case PipelineContextDataType.String:
var stringData = data as StringContextData;
return(new StringToken(null, null, null, stringData.Value));
case PipelineContextDataType.Boolean:
var booleanData = data as BooleanContextData;
return(new BooleanToken(null, null, null, booleanData.Value));
case PipelineContextDataType.Number:
var numberData = data as NumberContextData;
return(new NumberToken(null, null, null, numberData.Value));
default:
throw new NotSupportedException($"Unexpected {nameof(PipelineContextDataType)} type '{data.Type}'");
}
}
public Boolean AllowSequenceStart(out SequenceToken sequence)
{
var current = m_enumerator.Current;
if (current.Type == ParseEventType.SequenceStart)
{
sequence = new SequenceToken(m_fileId, current.Line, current.Column);
m_enumerator.MoveNext();
return(true);
}
sequence = null;
return(false);
}
/// <summary>
/// Formats content of <see cref="SequenceToken"/>.
/// </summary>
/// <param name="token">Token to be formatted.</param>
public void Format(SequenceToken token)
{
_output.Write('[');
int allButLast = token.Elements.Count - 1;
for (int i = 0; i < allButLast; ++i)
{
token.Elements[i].Render(this);
_output.Write(", ");
}
if (token.Elements.Count > 0)
{
token.Elements[token.Elements.Count - 1].Render(this);
}
_output.Write(']');
}
public List <string> EvaluateContainerArguments(
IExecutionContext executionContext,
SequenceToken token,
IDictionary <string, PipelineContextData> extraExpressionValues)
{
var result = new List <string>();
if (token != null)
{
var context = CreateContext(executionContext, extraExpressionValues);
try
{
var evaluateResult = TemplateEvaluator.Evaluate(context, "container-runs-args", token, 0, null, omitHeader: true);
context.Errors.Check();
Trace.Info($"Arguments evaluate result: {StringUtil.ConvertToJson(evaluateResult)}");
// Sequence
var args = evaluateResult.AssertSequence("container args");
foreach (var arg in args)
{
var str = arg.AssertString("container arg").Value;
result.Add(str);
Trace.Info($"Add argument {str}");
}
}
catch (Exception ex) when(!(ex is TemplateValidationException))
{
Trace.Error(ex);
context.Errors.Add(ex);
}
context.Errors.Check();
}
return(result);
}
public void SequenceToken_NullSequence_SequenceContainsZeroElements()
{
var sequence = new SequenceToken(null);
Assert.Equal(0, sequence.Elements.Count);
}
public override string ToString()
{
return(string.Format("<SimpleQueueCacheCursor: Element={0}, SequenceToken={1}>",
Element != null ? Element.Value.Batch.ToString() : "null", SequenceToken != null ? SequenceToken.ToString() : "null"));
}
internal void AddBytes(SequenceToken sequence)
{
var bytes = CalculateBytes(sequence);
AddBytes(bytes);
}
public void Render_NullFormatter_ThrowsArgumentNullException()
{
var sequence = new SequenceToken(null);
Assert.Throws <ArgumentNullException>(() => sequence.Render(null));
}
