Функция ТекущийПоток(): данные и событие завершения потока исполнения

src/OneScript.Core/Execution/IBslProcess.cs

@@ -7,6 +7,7 @@ This Source Code Form is subject to the terms of the
 
 #nullable enable
 
+using System;
 using OneScript.Contexts;
 using OneScript.DependencyInjection;
 using OneScript.Values;
@@ -15,7 +16,10 @@ This Source Code Form is subject to the terms of the
 namespace OneScript.Execution
 {
     /// <summary>
-    /// Готовый к исполнению bsl-процесс, с настроенным окружением
+    /// Готовый к исполнению bsl-процесс, с настроенным окружением.
+    ///
+    /// Процесс освобождается тем, кто его создал, когда единица исполнения отработала.
+    /// Освобождение завершает поток исполнения процесса.
     /// </summary>
     public interface IBslProcess
     {
@@ -33,7 +37,18 @@ public interface IBslProcess
         /// Сервисы текущего процесса
         /// </summary>
         public IServiceContainer Services { get; }
-        
+
         public int VirtualThreadId { get; }
+
+        /**
+         * Обертка текущего процесса в терминах BSL.
+         * Может отсутствовать, полностью определяется хост-приложением процесса.
+         */
+        public IRuntimeContextInstance? BslWrapper
+        {
+            get => null;
+            // ReSharper disable once ValueParameterNotUsed
+            set { }
+        }
     }
 }

src/OneScript.StandardLibrary/ExecutionThreadContext.cs

@@ -0,0 +1,133 @@
+/*----------------------------------------------------------
+This Source Code Form is subject to the terms of the
+Mozilla Public License, v.2.0. If a copy of the MPL
+was not distributed with this file, You can obtain one
+at http://mozilla.org/MPL/2.0/.
+----------------------------------------------------------*/
+
+using System;
+using System.Linq;
+using OneScript.Contexts;
+using OneScript.Execution;
+using OneScript.StandardLibrary.Collections;
+using ScriptEngine;
+using ScriptEngine.Machine;
+using ScriptEngine.Machine.Contexts;
+
+namespace OneScript.StandardLibrary
+{
+    /// <summary>
+    /// Поток исполнения bsl-кода.
+    ///
+    /// Потоком исполнения является каждая независимая единица исполнения: основной скрипт,
+    /// каждое фоновое задание и каждый обрабатываемый запрос веб-сервера. Получить поток
+    /// исполнения текущего кода можно функцией ТекущийПоток().
+    ///
+    /// Свойство Данные представляет собой хранилище, живущее ровно столько же, сколько живёт
+    /// сам поток исполнения. Оно предназначено для библиотек, которым нужно хранить состояние
+    /// в разрезе единицы исполнения (аналог thread-local хранилища).
+    ///
+    /// По завершении потока исполнения поднимается событие ПриЗавершении (оно же OnTermination),
+    /// на которое можно подписаться штатным способом:
+    ///
+    ///     ДобавитьОбработчик ТекущийПоток().ПриЗавершении, ЭтотОбъект.ВернутьСоединениеВПул;
+    ///
+    /// Обработчик вызывается до очистки данных потока, поэтому ещё видит их содержимое.
+    /// Это позволяет владельцам ресурсов узнавать о конце единицы исполнения вместо того,
+    /// чтобы опрашивать список фоновых заданий.
+    /// </summary>
+    [ContextClass("ПотокИсполнения", "ExecutionThread")]
+    public sealed class ExecutionThreadContext : AutoContext<ExecutionThreadContext>, IDisposable
+    {
+        private readonly IBslProcess _process;
+
+        private bool _isDisposed;
+
+        private ExecutionThreadContext(IBslProcess process)
+        {
+            _process = process;
+        }
+
+        /// <summary>
+        /// Идентификатор потока исполнения. Предназначен для диагностики и журналирования.
+        ///
+        /// Идентификаторы выдаются последовательно и в пределах запущенного движка не повторяются,
+        /// пока счётчик не исчерпает диапазон Int32. Для хранения состояния в разрезе потока
+        /// исполнения используйте свойство Данные, а не идентификатор в качестве ключа.
+        /// </summary>
+        /// <value>Число. Идентификатор потока исполнения.</value>
+        [ContextProperty("Идентификатор", "Id")]
+        public int Identifier => _process.VirtualThreadId;
+
+        /// <summary>
+        /// Хранилище данных потока исполнения, аналог набора thread-local переменных.
+        ///
+        /// Соответствие создаётся вместе с потоком исполнения и не разделяется с другими потоками.
+        /// В конце потока исполнения соответствие очищается, а его значения, поддерживающие
+        /// интерфейс IDisposable среды CLR, принудительно освобождаются.
+        /// </summary>
+        /// <value>Соответствие. Данные потока исполнения.</value>
+        [ContextProperty("Данные", "Data")]
+        public MapImpl Data { get; } = new MapImpl();
+
+        /// <summary>
+        /// Возвращает поток исполнения указанного bsl-процесса, создавая его при первом обращении.
+        /// Для одного процесса всегда возвращается один и тот же экземпляр.
+        ///
+        /// Созданный поток остаётся на процессе и освобождается вместе с ним.
+        /// </summary>
+        internal static ExecutionThreadContext Of(IBslProcess process)
+        {
+            if (process.BslWrapper is ExecutionThreadContext wrapper)
+                return wrapper;
+
+            lock (process)
+            {
+                if (process.BslWrapper is ExecutionThreadContext created)
+                    return created;
+
+                if (process.BslWrapper != null)
+                    throw new InvalidOperationException($"BslWrapper for process is not {nameof(ExecutionThreadContext)}: {process.BslWrapper.GetType()}");
+
+                var thread = new ExecutionThreadContext(process);
+                process.BslWrapper = thread;
+
+                return thread;
+            }
+        }
+
+        public void Dispose()
+        {
+            // Пока идёт завершение, поток ещё числится за процессом, и обработчик вправе
+            // добраться до него через ТекущийПоток(). Если он при этом освободит процесс,
+            // завершение не должно пойти по второму кругу.
+            if (_isDisposed)
+                return;
+
+            _isDisposed = true;
+
+            try
+            {
+                foreach (var item in Data.ToArray())
+                {
+                    if (item.Value is not IDisposable disposable)
+                        continue;
+
+                    try
+                    {
+                        disposable.Dispose();
+                    }
+                    catch (Exception exception)
+                    {
+                        SystemLogger.Write(
+                            $"WARNING! Error releasing execution thread data '{item.Key}': {exception.Message}");
+                    }
+                }
+            }
+            finally
+            {
+                Data.Clear();
+            }
+        }
+    }
+}

src/OneScript.StandardLibrary/StandardGlobalContext.cs

@@ -75,6 +75,28 @@ public void RunGarbageCollection()
             GC.WaitForPendingFinalizers();
         }
 
+        /// <summary>
+        /// Возвращает поток исполнения, в котором выполняется текущий код.
+        ///
+        /// Отдельным потоком исполнения является каждая независимая единица исполнения bsl-кода:
+        /// основной скрипт, каждое фоновое задание и каждый обрабатываемый запрос веб-сервера.
+        /// Для одной единицы исполнения всегда возвращается один и тот же объект, поэтому его
+        /// свойство Данные можно использовать как набор thread-local переменных.
+        ///
+        /// В отличие от идентификатора фонового задания, поток исполнения определён во всех
+        /// контекстах, в том числе при обработке запросов веб-сервера, где фоновое задание
+        /// отсутствует.
+        ///
+        /// Поток исполнения не наследуется: фоновое задание, запущенное из текущего потока
+        /// исполнения, получит собственный поток с собственными данными.
+        /// </summary>
+        /// <returns>ПотокИсполнения. Поток исполнения текущего кода.</returns>
+        [ContextMethod("ТекущийПоток", "CurrentThread")]
+        public ExecutionThreadContext CurrentThread(IBslProcess process)
+        {
+            return ExecutionThreadContext.Of(process);
+        }
+
         /// <summary>
         /// Приостанавливает выполнение скрипта.
         /// </summary>

src/OneScript.StandardLibrary/Tasks/BackgroundTasksManager.cs

@@ -1,4 +1,4 @@
-/*----------------------------------------------------------
+/*----------------------------------------------------------
 This Source Code Form is subject to the terms of the
 Mozilla Public License, v.2.0. If a copy of the MPL
 was not distributed with this file, You can obtain one

src/ScriptEngine.HostedScript/DefaultEventProcessor.cs

@@ -114,6 +114,14 @@ public void RemoveHandler(
             }
         }
 
+        public void RemoveAllHandlers(IRuntimeContextInstance eventSource)
+        {
+            lock (_subscriptionLock)
+            {
+                _registeredHandlers.Remove(eventSource);
+            }
+        }
+
         public void HandleEvent(IRuntimeContextInstance eventSource, string eventName, IValue[] eventArgs,
             IBslProcess process)
         {

src/ScriptEngine/BslProcess.cs

@@ -18,10 +18,13 @@ namespace ScriptEngine
 {
     internal class BslProcess : IBslProcess
     {
+        private static readonly string[] TerminationEventNames = { "ПриЗавершении", "OnTermination" };
+
         private readonly IExecutorProvider[] _executorProviders;
         private readonly IDictionary<Type, Invoker> _bslExecutorsByModule;
 
         private bool _isRunning;
+        private bool _disposed;
 
         public BslProcess(int id, ExecutionContext context, IEnumerable<IExecutorProvider> executorProviders)
         {
@@ -55,10 +58,51 @@ public BslValue Run(BslObjectValue target, IExecutableModule module, BslScriptMe
             {
                 if (notifyExecutors)
                 {
+                    RaiseTerminationEvent();
+                    if (BslWrapper is IDisposable disposable)
+                    {
+                        disposable.Dispose();
+                    }
+
                     Array.ForEach(_executorProviders, e => e.AfterProcessExit(this));
+                    Services.Dispose();
                     _isRunning = false;
                 }
             }
         }
+
+        public IRuntimeContextInstance BslWrapper { get; set; }
+
+        private void RaiseTerminationEvent()
+        {
+            if (BslWrapper == null)
+                return;
+
+            var eventProcessor = Services.TryResolve<IEventProcessor>();
+            if (eventProcessor == null)
+                return;
+
+            try
+            {
+                foreach (var eventName in TerminationEventNames)
+                {
+                    try
+                    {
+                        eventProcessor.HandleEvent(BslWrapper, eventName, Array.Empty<IValue>(), this);
+                    }
+                    catch (Exception exception)
+                    {
+                        SystemLogger.Write(
+                            $"WARNING! Error in execution thread termination handler '{eventName}': {exception.Message}");
+                    }
+                }
+            }
+            finally
+            {
+                // Процессор событий держит источник, пока подписки не сняты. Потоков исполнения
+                // много и живут они недолго, поэтому без явного снятия реестр рос бы бесконечно.
+                eventProcessor.RemoveAllHandlers(BslWrapper);
+            }
+        }
     }
 }

src/ScriptEngine/Machine/IEventProcessor.cs

@@ -25,5 +25,17 @@ void RemoveHandler(
             string handlerMethod);
 
         void HandleEvent(IRuntimeContextInstance eventSource, string eventName, IValue[] eventArgs, IBslProcess process);
+
+        /// <summary>
+        /// Снимает все подписки на события указанного источника.
+        ///
+        /// Нужен источникам, которые живут меньше самого процессора событий: без этого реестр
+        /// подписок удерживает такой источник до конца работы движка. Реализация по умолчанию
+        /// ничего не делает, чтобы не ломать сторонние процессоры событий.
+        /// </summary>
+        /// <param name="eventSource">Источник, подписки на который нужно снять.</param>
+        void RemoveAllHandlers(IRuntimeContextInstance eventSource)
+        {
+        }
     }
 }

src/Tests/OneScript.Core.Tests/BslProcessTests.cs

@@ -0,0 +1,73 @@
+/*----------------------------------------------------------
+This Source Code Form is subject to the terms of the
+Mozilla Public License, v.2.0. If a copy of the MPL
+was not distributed with this file, You can obtain one
+at http://mozilla.org/MPL/2.0/.
+----------------------------------------------------------*/
+
+using System;
+using FluentAssertions;
+using ScriptEngine.Hosting;
+using Xunit;
+
+namespace OneScript.Core.Tests
+{
+    /// <summary>
+    /// Регистрируется как scoped, поэтому живёт ровно столько же, сколько область сервисов процесса.
+    /// </summary>
+    public sealed class ScopedDisposableProbe : IDisposable
+    {
+        public bool IsDisposed { get; private set; }
+
+        public void Dispose()
+        {
+            IsDisposed = true;
+        }
+    }
+
+    public class BslProcessTests
+    {
+        private static ScriptEngine.ScriptingEngine CreateEngineWithScopedProbe()
+        {
+            var builder = DefaultEngineBuilder.Create().SetDefaultOptions();
+            builder.Services.RegisterScoped<ScopedDisposableProbe>();
+
+            var engine = builder.Build();
+            engine.Initialize();
+
+            return engine;
+        }
+
+        [Fact]
+        public void ProcessReleasesItsServiceScope()
+        {
+            var engine = CreateEngineWithScopedProbe();
+
+            var process = engine.NewProcess();
+            var scoped = process.Services.Resolve<ScopedDisposableProbe>();
+
+            scoped.IsDisposed.Should().BeFalse("процесс ещё работает");
+
+            engine.AttachedScriptsFactory.LoadFromString(
+                engine.GetCompilerService(), "f = 1", process);
+
+            scoped.IsDisposed.Should().BeTrue("процесс владеет своей областью сервисов");
+        }
+
+        [Fact]
+        public void ProcessDoesNotReleaseScopeOfAnotherProcess()
+        {
+            var engine = CreateEngineWithScopedProbe();
+
+            var first = engine.NewProcess();
+            var second = engine.NewProcess();
+
+            var firstScoped = first.Services.Resolve<ScopedDisposableProbe>();
+            var secondScoped = second.Services.Resolve<ScopedDisposableProbe>();
+
+            firstScoped.Should().NotBeSameAs(secondScoped, "у каждого процесса своя область сервисов");
+
+            secondScoped.IsDisposed.Should().BeFalse("освобождение одного процесса не трогает другой");
+        }
+    }
+}