private async Task OperateLoop()
{
while (true)
{
await Inlets.AnyMessageAvailableAsync();
try
{
NodeDisposedToken.ThrowIfCancellationRequested();
var inletsBefore = Inlets.GetSnapshot();
await Operate();
_operationsCount++;
var inletsAfter = Inlets.GetSnapshot();
if (!Equals(inletsBefore, inletsAfter))
{
}
}
catch (OperationCanceledException ex) when(ex.CancellationToken == NodeDisposedToken)
{
break;
}
catch (Exception ex)
{
_exceptionsCount++;
Exception.Send(ex);
}
}
}
public NuGetListPackagesNode(Workspace workspace) : base(workspace)
{
Settings = Inlets.Create <ISettings>(nameof(Settings));
Repo = Outlets.Create <string>(nameof(Repo));
Settings.OnNext(NuGet.Configuration.Settings.LoadDefaultSettings("."));
}
private void RebuildScript()
{
var options = ScriptOptions.Default
.AddReferences(
typeof(DynamicObject).GetTypeInfo().Assembly,
typeof(CSharpArgumentInfo).GetTypeInfo().Assembly,
typeof(ExpandoObject).GetTypeInfo().Assembly)
.AddImports(typeof(Math).Namespace);
var usedVars = new HashSet <string>();
var removeUnused = false;
foreach (var diagnostic in CSharpScript.Create(_latestExpression, options).Compile())
{
if (diagnostic.Id == "CS0103")
{
var missedVariable = diagnostic.Location.SourceTree.GetCompilationUnitRoot().FindToken(diagnostic.Location.SourceSpan.Start).Text;
usedVars.Add(missedVariable);
removeUnused = true;
}
}
var unusedVars = new HashSet <string>(_variables.Keys);
unusedVars.ExceptWith(usedVars);
var sb = new StringBuilder();
foreach (var variableName in usedVars)
{
if (!_variables.TryGetValue(variableName, out Inlet inlet))
{
inlet = Inlets.Create("var" + Interlocked.Increment(ref _counter));
((IObserver <object>)inlet).OnNext(null);
_variables.Add(variableName, inlet);
inlet.SetAttribute("title", variableName);
inlet.SetAttribute("is-title-editable", "true");
}
sb.AppendLine($"dynamic {variableName} = (dynamic)__globals__[\"{variableName}\"];");
}
if (removeUnused)
{
foreach (var variableName in unusedVars)
{
Inlets.Destroy(_variables[variableName]);
_variables.Remove(variableName);
}
}
var script = CSharpScript
.Create(sb.ToString(), options, typeof(Globals))
.ContinueWith(_latestExpression);
script.Compile();
_script = script;
}
protected override async Task Operate()
{
var currentIsEnabled = false;
var currentInterval = default(TimeSpan);
var stopwatch = Stopwatch.StartNew();
var counter = 0;
var ticksElapsed = 0;
while (true)
{
var newIsEnabled = await IsEnabled;
var newInterval = await Interval;
var useLocalTimeZone = await UseLocalTimeZone;
var shouldPost = true;
if (currentIsEnabled != newIsEnabled || currentInterval != newInterval)
{
shouldPost = false;
stopwatch = Stopwatch.StartNew();
ticksElapsed = 0;
currentIsEnabled = newIsEnabled;
currentInterval = newInterval;
if (!currentIsEnabled || currentInterval.TotalMilliseconds <= 0)
{
break;
}
}
if (shouldPost)
{
ticksElapsed++;
counter++;
Counter.Send(counter);
Timestamp.Send(useLocalTimeZone ? DateTimeOffset.Now : DateTimeOffset.UtcNow);
}
using (var cts1 = new CancellationTokenSource())
using (var cts2 = CancellationTokenSource.CreateLinkedTokenSource(cts1.Token, NodeDisposedToken))
{
var delayTask = GetDelayTask(stopwatch.Elapsed, ticksElapsed, currentInterval, cts2.Token);
if (delayTask.Status != TaskStatus.RanToCompletion)
{
await Task.WhenAny(
delayTask.IgnoreCancellation(),
Inlets.AnyMessageAvailableAsync());
cts1.Cancel();
}
}
NodeDisposedToken.ThrowIfCancellationRequested();
}
}
protected override Func <TMessage> FindSender(IOutlet <TMessage> outletReceivingMessage)
{
var senders = Inlets.Select((inlet, index) => new Tuple <int, Func <TMessage> >(index, inlet.FindSender())).Where(t => t.Item2 != null).ToList();
if (!senders.Any())
{
return(null);
}
var result = TieBreaker.ResolveTie(senders.Select(s => s.Item1));
return(senders.Single(s => s.Item1 == result).Item2);
}
private void SetupAttributtedPins()
{
foreach (var propertyInfo in GetType().GetRuntimeProperties())
{
var propertyTypeInfo = propertyInfo.PropertyType.GetTypeInfo();
if (propertyTypeInfo.IsGenericType && propertyTypeInfo.GetGenericTypeDefinition() == typeof(Inlet <>))
{
var designerPropertiesAttributes = propertyInfo.GetCustomAttributes <DesignerPropertiesAttribute>();
var basicInlet = Inlets.Create(propertyInfo.Name);
basicInlet.SetAttribute("type", propertyTypeInfo.GenericTypeArguments[0].AssemblyQualifiedName);
var inlet = CastInlet(basicInlet, propertyTypeInfo.GenericTypeArguments[0]);
propertyInfo.SetValue(this, inlet);
}
if (propertyTypeInfo.IsGenericType && propertyTypeInfo.GetGenericTypeDefinition() == typeof(Outlet <>))
{
var designerPropertiesAttributes = propertyInfo.GetCustomAttributes <DesignerPropertiesAttribute>();
var nonTypedOutlet = Outlets.Create(propertyInfo.Name);
nonTypedOutlet.SetAttribute("type", propertyTypeInfo.GenericTypeArguments[0].AssemblyQualifiedName);
var outlet = CastOutlet(nonTypedOutlet, propertyTypeInfo.GenericTypeArguments[0]);
propertyInfo.SetValue(this, outlet);
}
}
}
/// <summary> /// TBD /// </summary> /// <returns>TBD</returns> public override Shape DeepCopy() => new AmorphousShape(Inlets.Select(i => i.CarbonCopy()).ToImmutableArray(), Outlets.Select(o => o.CarbonCopy()).ToImmutableArray());
/// <summary> /// Compare this to another shape and determine whether the arrangement of ports is the same (including their ordering). /// </summary> /// <param name="shape">TBD</param> /// <returns>TBD</returns> public bool HasSamePortsAndShapeAs(Shape shape) => Inlets.Equals(shape.Inlets) && Outlets.Equals(shape.Outlets);
