MORYX-Framework/src/Moryx.ProcessData.Adapter.ProcessEngine/ProcessEngineAdapter.cs at dev · PHOENIXCONTACT/MORYX-Framework · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
// Copyright (c) 2026 Phoenix Contact GmbH & Co. KG
// Licensed under the Apache License, Version 2.0

using System.Globalization;
using Moryx.AbstractionLayer.Processes;
using Moryx.AbstractionLayer.Products;
using Moryx.AbstractionLayer.Resources;
using Moryx.Container;
using Moryx.ControlSystem.Jobs;
using Moryx.ControlSystem.Processes;
using Moryx.Modules;
using Moryx.ProcessData.Bindings;

namespace Moryx.ProcessData.Adapter.ProcessEngine;

[Plugin(LifeCycle.Singleton)]
internal class ProcessEngineAdapter : IPlugin
{
    private const string MeasurementPrefix = "processEngine_";

    #region Fields and Properties

    private MeasurementBindingProcessor _processBindingProcessor;
    private MeasurementBindingProcessor _activityBindingProcessor;

    #endregion

    #region Dependencies

    public IProcessControl ProcessControl { get; set; }

    public IJobManagement JobManagement { get; set; }

    public IResourceManagement ResourceManagement { get; set; }

    public IProcessDataMonitor ProcessDataMonitor { get; set; }

    public ModuleConfig ModuleConfig { get; set; }

    #endregion

    /// <inheritdoc />
    public void Start()
    {
        var processResolverFactory = new ProcessBindingResolverFactory();
        _processBindingProcessor = new MeasurementBindingProcessor(processResolverFactory, ModuleConfig.ProcessBindings);

        var activityResolverFactory = new ResourceActivityBindingResolverFactory(ResourceManagement);
        _activityBindingProcessor = new MeasurementBindingProcessor(activityResolverFactory, ModuleConfig.ActivityBindings);

        ProcessControl.ProcessUpdated += OnProcessUpdated;
        ProcessControl.ActivityUpdated += OnActivityUpdated;
    }

    /// <summary>
    /// Stops the adapter component
    /// </summary>
    public void Stop()
    {
        ProcessControl.ActivityUpdated -= OnActivityUpdated;
        ProcessControl.ProcessUpdated -= OnProcessUpdated;
    }

    private void OnProcessUpdated(object sender, ProcessUpdatedEventArgs e)
    {
        // Process finished
        if (e.Progress == ProcessProgress.Completed)
        {
            var process = e.Process;
            var measurement = new Measurement(MeasurementPrefix + "processes");

            measurement.Add(new DataTag("id", process.Id.ToString(CultureInfo.InvariantCulture)));

            var success = process is ProductionProcess prodProcess && prodProcess.ProductInstance.State == ProductInstanceState.Success;
            measurement.Add(new DataField("success", success));

            var firstActivity = process.GetActivity(ActivitySelectionType.First);
            var lastActivity = process.GetActivity(ActivitySelectionType.Last);

            if (firstActivity != null && lastActivity != null)
            {
                var cycleTime = lastActivity.Tracing.Completed - firstActivity.Tracing.Started;
                if (cycleTime.HasValue)
                    measurement.Add(new DataField("cycleTime", cycleTime.Value));
            }

            _processBindingProcessor.Apply(measurement, process);

            ProcessDataMonitor.Add(measurement);
        }
    }

    private void OnActivityUpdated(object sender, ActivityUpdatedEventArgs args)
    {
        // Activity finished
        if (args.Progress == ActivityProgress.Completed && args.Activity.Result != null)
        {
            var activity = args.Activity;
            var process = activity.Process;

            var measurement = new Measurement(MeasurementPrefix + "activities");
            measurement.Add(new DataField("id", activity.Id));
            measurement.Add(new DataField("success", activity.Result.Success));
            measurement.Add(new DataField("process", process.Id));

            if (activity.Tracing.Started.HasValue && activity.Tracing.Completed.HasValue)
            {
                var runtimeTimespan = activity.Tracing.Completed - activity.Tracing.Started;
                measurement.Add(new DataField("runtimeMs", runtimeTimespan.Value));
            }

            var lastActivity = process.GetActivity(ActivitySelectionType.LastOrDefault, a => a.Id == activity.Id - 1);
            if (lastActivity != null && lastActivity.Tracing.Completed.HasValue &&
                activity.Tracing.Started.HasValue)
            {
                var waitTime = activity.Tracing.Started - lastActivity.Tracing.Completed;
                measurement.Add(new DataField("waitTimeMs", waitTime.Value));
            }

            measurement.Add(new DataTag("type", activity.GetType().Name));

            _activityBindingProcessor.Apply(measurement, activity);

            ProcessDataMonitor.Add(measurement);
        }
    }
}