/// <summary>
/// Explicitely instanciation of event argument.
/// </summary>
/// <param name="percentage">The percetange</param>
/// <param name="taskName">The task name</param>
/// <param name="state">The state</param>
/// <param name="reason">The action type</param>
internal NodeProgressEventArgs(LogReason reason, int percentage, string taskName = null, object state = null)
{
Percentage = Math.Max(0, Math.Min(100, percentage));
TaskName = taskName;
State = state;
Reason = reason;
}
/// <summary>
/// Wrapping an internal event reference.
/// </summary>
/// <param name="state">The source state</param>
/// <param name="taskName">The task name</param>
/// <param name="reason">The action type</param>
internal NodeProgressEventArgs(LogReason reason, ProgressStateToken state, string taskName = null)
{
InternalState = state;
TaskName = $"{taskName ?? state?.StateObject}";
State = state?.StateObject;
Percentage = state?.Percentage ?? 0;
Reason = reason;
}
internal LogMessage(string source, LogSeverity severity, LogReason reason, string template, params object[] args) : this()
{
Source = source;
Severity = severity;
Reason = reason;
messageTemplate = template;
this.args = args;
}
public OnLogHandlerArgs(string text, LogReason reason, OutputLevel outputLevel = OutputLevel.INFO)
{
Text = text;
Reason = reason;
OutputLevel = outputLevel;
}
/// <summary>
/// Notifies all sinks on progress end.
/// </summary>
/// <param name="action">The logging action happened</param>
/// <param name="isCanceled">Whether the progress was cancelled</param>
/// <param name="isBroken">Whether the progress was broken</param>
internal protected void NotifyOnProgressEnded(LogReason action, bool isCanceled, bool isBroken)
{
OnProgressEnded(new NodeProgressEndEventArgs(action, Name, isCanceled, isBroken));
}
/// <summary>
/// Notifies all sinks on progress change.
/// </summary>
/// <param name="action">The logging action happened</param>
/// <param name="percentage">The current percentage</param>
/// <param name="stateObject">The current state object</param>
internal protected void NotifyOnProgressChanged(LogReason action, int percentage, object stateObject)
{
OnProgressChanged(new NodeProgressEventArgs(action, percentage, Name, stateObject));
}
/// <summary>
/// Manually notifying on finish.
/// </summary>
/// <param name="finishAction">The finishing action.</param>
/// <param name="isBroken">Whether the finish is reached by error</param>
internal protected void OnProgressEnded(LogReason finishAction, bool isBroken)
{
OnProgressEnded(new NodeProgressEndEventArgs(finishAction, Name, false, isBroken));
}
/// <summary>
/// New progress end by giving explicit details.
/// </summary>
/// <param name="taskName">Taskname</param>
/// <param name="isCanceled">Cancellation flag</param>
/// <param name="isBroken">Broken flag</param>
/// <param name="reason">The action type</param>
/// <param name="stateObject">The end state object</param>
internal NodeProgressEndEventArgs(LogReason reason, string taskName, object stateObject = null, bool isCanceled = false, bool isBroken = false)
: base(reason, 100, taskName, stateObject)
{
IsCanceled = isCanceled;
IsBroken = isBroken;
}
/// <summary>
/// New progress end by internal state and task name.
/// </summary>
/// <param name="endState">The internal state</param>
/// <param name="taskName">The task name</param>
/// <param name="reason">The log reason type</param>
internal NodeProgressEndEventArgs(LogReason reason, ProgressStateToken endState, string taskName = null)
: base(reason, endState, taskName)
{
IsCanceled = endState?.State.HasFlag(ProgressTokenState.IsCanceled) ?? false;
IsBroken = endState?.State.HasFlag(ProgressTokenState.IsBroken) ?? false;
}
public static IfcModel BySourceAndTransform(IfcModel source, IfcTransform transform, string nameAddon, object objFilterMask)
{
if (null == source)
{
throw new ArgumentNullException(nameof(source));
}
if (null == transform)
{
throw new ArgumentNullException(nameof(transform));
}
if (null == nameAddon)
{
nameAddon = transform.Mark;
}
LogReason filterMask = DynamicArgumentDelegation.TryCastEnumOrDefault(objFilterMask, LogReason.Any);
if (null == transform.CancellationSource)
{
transform.CancellationSource = new CancellationTokenSource();
}
return(IfcStore.ByTransform(source, (model, node) =>
{
log.LogInformation("Starting '{1}' ({0}) on {2} ...", node.GetHashCode(), transform.transformDelegate.Name, node.Name);
try
{
using (var task = transform.transformDelegate.Run(model, node.CreateProgressMonitor(LogReason.Transformed)))
{
task.Wait(transform.TimeOutMillis, transform.CancellationSource.Token);
log.LogInformation("Finalized '{1}' ({0}) on {2}.", node.GetHashCode(), transform.transformDelegate.Name, node.Name);
if (task.IsCompleted)
{
if (node is ProgressingTask np)
{
np.OnProgressEnded(LogReason.Changed, false);
}
using (var result = task.Result)
{
switch (result.ResultCode)
{
case TransformResult.Code.Finished:
var name = $"{transform.transformDelegate.Name}({node.Name})";
node.OnActionLogged(TransformLogToMessage(name, result.Log, filterMask).ToArray());
return result.Target;
case TransformResult.Code.Canceled:
node.OnActionLogged(LogMessage.BySeverityAndMessage(
node.Name, LogSeverity.Error, LogReason.Any, "Canceled by user request ({0}).", node.Name));
break;
case TransformResult.Code.ExitWithError:
node.OnActionLogged(LogMessage.BySeverityAndMessage(
node.Name, LogSeverity.Error, LogReason.Any, "Caught error ({0}): {1}", node.Name, result.Cause));
break;
}
}
}
else
{
if (node is ProgressingTask np)
{
np.OnProgressEnded(LogReason.Changed, true);
}
node.OnActionLogged(LogMessage.BySeverityAndMessage(
node.Name, LogSeverity.Error, LogReason.Changed, $"Task incompletely terminated (Status {task.Status})."));
}
return null;
}
}
catch (Exception thrownOnExec)
{
log.LogError("{0} '{1}'\n{2}", thrownOnExec, thrownOnExec.Message, thrownOnExec.StackTrace);
throw new Exception("Exception while executing task");
}
}, nameAddon));
}
private static IEnumerable <LogMessage> TransformLogToMessage(string storeName, IEnumerable <TransformLogEntry> logEntries, LogReason filter = LogReason.Any)
{
foreach (var entry in logEntries)
{
var action = TransformActionToActionType(entry.performed);
if (LogReason.None != (filter & action))
{
yield return(LogMessage.BySeverityAndMessage(
storeName,
LogSeverity.Info,
action, "#{0} {1}",
entry.handle.EntityLabel.ToString() ?? "(not set)",
entry.handle.EntityExpressType.Name ?? "(type unknown)"));
}
}
}
