implab/ImplabNet Commit - r256:c52691faaf21

Removed obsolete App, ComponentContainer...

cin -

r256:c52691faaf21 v3

parent child

Context file:

r256:c52691faaf21

Collapse all files

Implab/Components/IAsyncComponent.cs created 644 +37 0

@@ -0,0 +1,37
	1	using System;
	2	using System.Threading.Tasks;
	3
	4	namespace Implab.Components {
	5	/// <summary>
	6	/// An interface for asynchronous components.
	7	/// </summary>
	8	/// <remarks>
	9	/// <para>
	10	/// Асинхронные компоненты не предназначены для одновременного использования несколькими клиентами,
	11	/// однако существуют внутренние процессы, изменяющее состояние компонент без участия клиента.
	12	/// Данный интерфейс определяет протокол взаимодействия с компонентой, при которм компоненте
	13	/// посылаются сигналы от клиента, в ответ на которые компонента меняет свойство <see cref="Completion"/>,
	14	/// данное свойство содержит в себе новую задачу, выполняемую компонентой и данное свойство
	15	/// может измениться только при получении нового сигнала от клиента.
	16	/// </para>
	17	/// <para>
	18	/// В дополнение к <see cref="Completion"/> компонента может определять другие свойства, в
	19	/// которых будет передаваться информация о результате выполнения операции.
	20	/// </para>
	21	/// <para>
	22	/// Особое внимание следует уделить реализации <see cref="IDisposable"/>, который по своей природе
	23	/// синхронный, данное правило безусловно можно нарушить, но тогда могут возникнуть проблемы с
	24	/// тем, что ресурсы еще не освободились, а ход программы продолжается, что приведет к ошибкам,
	25	/// например при попытке получить ресуср другим объектом, либо при заврешении программы.
	26	/// </para>
	27	/// <seealso href="https://blog.stephencleary.com/2013/01/async-oop-0-introduction.html"/>
	28	/// </remarks>
	29	public interface IAsyncComponent {
	30	/// <summary>
	31	/// The result of the last started operation. This property reflects
	32	/// only the result of the last started operation and therefore should
	33	/// change only if a new operation is initiated.
	34	/// </summary>
	35	Task Completion { get; }
	36	}
	37	} No newline at end of file

Implab.Test/Implab.Test.csproj +1 -1

             <Project Sdk="Microsoft.NET.Sdk">
               <PropertyGroup>
                 <TargetFramework>net46</TargetFramework>
-                <FrameworkPathOverride Condition="'$(TargetFramework)'=='net45' and '$(OSTYPE)'=='linux'">/usr/lib/mono/4.5/</FrameworkPathOverride>
+                <FrameworkPathOverride Condition="'$(TargetFramework)'=='net46' and '$(OSTYPE)'=='linux'">/usr/lib/mono/4.5/</FrameworkPathOverride>
                 <IsPackable>false</IsPackable>
               </PropertyGroup>
               <ItemGroup>
                 <ProjectReference Include="../Implab/Implab.csproj" />
                 <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
                 <PackageReference Include="xunit" Version="2.3.1" />
                 <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
                 <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.1" />
               </ItemGroup>
             </Project>

Implab.Test/UnitTest1.cs +16 -5

             using System;
             using System.Diagnostics;
             using System.Threading;
             using Implab.Diagnostics;
+            using System.Linq;
             using Xunit;
             namespace Implab.Test {
                 using System.Threading.Tasks;
                 using static Trace<UnitTest1>;
                 public class UnitTest1 {
                     [Fact]
                     public async Task Test1() {
                         var listener = new SimpleTraceListener(Console.Out);
+                        listener.TraceOutputOptions |= TraceOptions.ThreadId;
                         var source = TraceSource;
                         source.Switch.Level = SourceLevels.All;
                         source.Listeners.Add(listener);
-                        using (var op = LogicalOperation(nameof(Test1)))
+                        using (LogicalOperation("Test1")){
-                        using (LogicalOperation("InnerOperation")){
                             await Task.Yield();
-                            Log("Inner");
+                            Log(String.Join(", ", Trace.CorrelationManager.LogicalOperationStack.Cast<object>().Select(x => x.ToString())));
-                            await Task.Yield();
+                            await AsyncDummy();
-                            Log("source event");
+                            Log(String.Join(", ", Trace.CorrelationManager.LogicalOperationStack.Cast<object>().Select(x => x.ToString())));
                         }
                     }
+                    async Task AsyncDummy() {
+                        using(LogicalOperation("OuterDummy"))
+                        using(LogicalOperation("InnerDummy")) {
+                            Log(String.Join(", ", Trace.CorrelationManager.LogicalOperationStack.Cast<object>().Select(x => x.ToString())));
+                            await Task.Delay(1);
+                            Log(String.Join(", ", Trace.CorrelationManager.LogicalOperationStack.Cast<object>().Select(x => x.ToString())));
+                        }
+                        Log(String.Join(", ", Trace.CorrelationManager.LogicalOperationStack.Cast<object>().Select(x => x.ToString())));
+                    }
                 }
             }

Implab/Components/DisposablePool.cs +2 -2

             using System;
             using Implab.Parallels;
             using System.Threading;
             using System.Diagnostics;
             using System.Diagnostics.CodeAnalysis;
             namespace Implab.Components {
                 /// <summary>
-                /// The base class for implementing pools of disposable objects.
+                /// The base class for implementing thread-safe pools of disposable objects.
                 /// </summary>
                 /// <remarks>
-                /// <para>This class maintains a set of pre-created objects and which are frequently allocated and released
+                /// <para>This class maintains a set of pre-created objects which are frequently allocated and released
                 /// by clients. The pool maintains maximum number of unsued object, any object above this limit is disposed,
                 /// if the pool is empty it will create new objects on demand.</para>
                 /// <para>Instances of this class are thread-safe.</para>
                 /// </remarks>
                 public abstract class DisposablePool<T> : IDisposable {
                     readonly int m_size;
                     readonly AsyncQueue<T> m_queue = new AsyncQueue<T>();
                     [SuppressMessage("Microsoft.Design", "CA1000:DoNotDeclareStaticMembersOnGenericTypes")]
                     static readonly bool _isValueType = typeof(T).IsValueType;
                     bool m_disposed;
                     int m_count;
                     protected DisposablePool(int size) {
                         m_size = size;
                     }
                     protected DisposablePool() : this(Environment.ProcessorCount+1) {
                     }
                     public T Allocate() {
                         if (m_disposed)
                             throw new ObjectDisposedException(ToString());
                         T instance;
                         if (m_queue.TryDequeue(out instance)) {
                             Interlocked.Decrement(ref m_count);
                         } else {
                             instance = CreateInstance();
                             Debug.Assert(!Object.Equals(instance, default(T)) || _isValueType);
                         }
                         return instance;
                     }
                     protected abstract T CreateInstance();
                     protected virtual void CleanupInstance(T instance) {
                     }
                     public void Release(T instance) {
                         if ( Object.Equals(instance,default(T)) && !_isValueType)
                             return;
                         Thread.MemoryBarrier();
                         if (m_count < m_size && !m_disposed) {
                             Interlocked.Increment(ref m_count);
                             CleanupInstance(instance);
                             m_queue.Enqueue(instance);
                             // пока элемент возвращался в кеш, была начата операция освобождения всего кеша
                             // и возможно уже законцена, в таком случае следует извлечь элемент обратно и
                             // освободить его. Если операция освобождения кеша еще не заврешилась, то будет
                             // изъят и освобожден произвольный элемен, что не повлияет на ход всего процесса.
                             if (m_disposed && m_queue.TryDequeue(out instance) && instance is IDisposable)
                                 ((IDisposable)instance).Dispose() ;
                         } else {
                             var disposable = instance as IDisposable;
                             if (disposable != null)
                                 disposable.Dispose();
                         }
                     }
                     protected virtual void Dispose(bool disposing) {
                         if (disposing) {
                             m_disposed = true;
                             T instance;
                             while (m_queue.TryDequeue(out instance)) {
                                 var disposable = instance as IDisposable;
                                 if (disposable != null)
                                     disposable.Dispose();
                             }
                         }
                     }
                     #region IDisposable implementation
                     public void Dispose() {
                         Dispose(true);
                         GC.SuppressFinalize(this);
                     }
                     #endregion
                 }
             }

Implab/Components/IRunnable.cs +1 -8

             using System;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Components {
                 /// <summary>
                 /// Interface for the component which performs a long running task.
                 /// </summary>
                 /// <remarks>
                 /// The access to the runnable component should be sequential, the
                 /// componet should support asynchronous completion of the initiated
                 /// operation but operations itself must be initiated sequentially.
                 /// </remarks>
                 public interface IRunnable {
                     /// <summary>
                     /// Starts this instance
                     /// </summary>
                     /// <remarks>
                     /// This operation is cancellable and it's expected to move to
                     /// the failed state or just ignore the cancellation request,
                     /// </remarks>
                     void Start(CancellationToken ct);
                     /// <summary>
                     /// Stops this instance and releases all resources, after the
                     /// instance is stopped it is moved to Disposed state and
                     /// can't be reused.
                     /// </summary>
                     /// <remarks>
                     /// If the componet was in the starting state the pending operation
                     /// will be requested to cancel. The stop operatin will be
                     /// performed only if the component in the running state.
                     /// </remarks>
                     void Stop(CancellationToken ct);
                     /// <summary>
-                    /// The result of the last started operation. This property reflects
+                    /// Current state of the componenet, dynamically reflects the current state.
-                    /// only the result of the last started operation and therefore should
-                    /// change only if a new operation is initiated.
-                    /// </summary>
-                    Task Completion { get; }
-                    /// <summary>
-                    /// Current state of the componenet
                     /// </summary>
                     ExecutionState State { get; }
                     /// <summary>
                     /// Event to monitor the state of the component.
                     /// </summary>
                     event EventHandler<StateChangeEventArgs> StateChanged;
                     /// <summary>
                     /// The last error
                     /// </summary>
                     Exception LastError { get; }
                 }
             }

Implab/Components/RunnableComponent.cs +28 -11

             using System;
             using System.Diagnostics;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Components {
                 /// <summary>
                 /// Base class for implementing components which support start and stop operations,
                 /// such components may represent running services.
                 /// </summary>
                 /// <remarks>
                 /// This class provides a basic lifecycle from the creation to the
                 /// termination of the component.
                 /// </remarks>
-                public class RunnableComponent : IRunnable, IInitializable, IDisposable {
+                public class RunnableComponent : IAsyncComponent, IRunnable, IInitializable, IDisposable {
                     /// <summary>
                     /// This class bounds <see cref="CancellationTokenSource"/> lifetime to the task,
                     /// when the task completes the associated token source will be disposed.
                     /// </summary>
                     class AsyncOperationDescriptor {
                         public static AsyncOperationDescriptor None { get; } = new AsyncOperationDescriptor();
                         readonly CancellationTokenSource m_cts;
                         bool m_done;
                         public CancellationToken Token {
                             get { return m_cts == null ? CancellationToken.None : m_cts.Token; }
                         }
                         public Task Task { get; private set; }
                         private AsyncOperationDescriptor(Task task, CancellationTokenSource cts) {
                             m_cts = cts;
                             Task = Chain(task);
                         }
                         private AsyncOperationDescriptor() {
                             Task = Task.CompletedTask;
                         }
                         public void Cancel() {
                             if (m_cts != null) {
                                 lock (m_cts) {
                                     if (!m_done)
                                         m_cts.Cancel();
                                 }
                             }
                         }
                         void Done() {
                             if (m_cts != null) {
                                 lock (m_cts) {
                                     m_done = true;
                                     m_cts.Dispose();
                                 }
                             } else {
                                 m_done = true;
                             }
                         }
                         async Task Chain(Task other) {
                             try {
                                 await other;
                             } finally {
                                 Done();
                             }
                         }
                         public static AsyncOperationDescriptor Create(Func<CancellationToken, Task> factory, CancellationToken ct) {
                             var cts = ct.CanBeCanceled ?
                                 CancellationTokenSource.CreateLinkedTokenSource(ct) :
                                 new CancellationTokenSource();
                             return new AsyncOperationDescriptor(factory(cts.Token), cts);
                         }
                     }
                     // this lock is used to synchronize state flow of the component during
-                    // completions or the operations.
+                    // processing calls from a client and internal processes.
                     readonly object m_lock = new object();
                     // current operation cookie, used to check wheather a call to
                     // MoveSuccess/MoveFailed method belongs to the current
                     // operation, if cookies didn't match ignore completion result.
                     object m_cookie;
+                    // AsyncOperationDscriptor aggregates a task and it's cancellation token
                     AsyncOperationDescriptor m_current = AsyncOperationDescriptor.None;
                     ExecutionState m_state;
                     protected RunnableComponent(bool initialized) {
                         State = initialized ? ExecutionState.Ready : ExecutionState.Created;
                     }
                     public Task Completion {
                         get { return m_current.Task; }
                     }
                     public ExecutionState State {
                         get { return m_state; }
                         private set {
                             if (m_state != value) {
                                 m_state = value;
                                 StateChanged.DispatchEvent(this, new StateChangeEventArgs {
                                     State = value,
                                     LastError = LastError
                                 });
                             }
                         }
                     }
                     public Exception LastError { get; private set; }
                     public event EventHandler<StateChangeEventArgs> StateChanged;
                     /// <summary>
                     /// Releases all resources used by the current component regardless of its
                     /// execution state.
                     /// </summary>
                     /// <remarks>
                     /// Calling to this method may result unexpedted results if the component
                     /// isn't in the stopped state. Call this method after the component is
                     /// stopped if needed or if the component is in the failed state.
                     /// </remarks>
                     public void Dispose() {
                         bool dispose = false;
                         if (dispose) {
                             Dispose(true);
                             GC.SuppressFinalize(this);
                         }
                     }
                     ~RunnableComponent() {
                         Dispose(false);
                     }
                     /// <summary>
                     /// Releases all resources used by the current component regardless of its
                     /// execution state.
                     /// </summary>
                     /// <param name="disposing">Indicates that the component is disposed
                     /// during a normal disposing or during GC.</param>
                     protected virtual void Dispose(bool disposing) {
                     }
                     public void Initialize() {
                         var cookie = new object();
                         if (MoveInitialize(cookie))
                             ScheduleTask(InitializeInternalAsync, CancellationToken.None, cookie);
+                        else
+                            throw new InvalidOperationException();
                     }
                     /// <summary>
                     /// This method is used for initialization during a component creation.
                     /// </summary>
                     /// <param name="ct">A cancellation token for this operation</param>
                     /// <remarks>
                     /// This method should be used for short and mostly syncronous operations,
                     /// other operations which require time to run shoud be placed in
                     /// <see cref="StartInternalAsync(CancellationToken)"/> method.
                     /// </remarks>
                     protected virtual Task InitializeInternalAsync(CancellationToken ct) {
                         return Task.CompletedTask;
                     }
                     public void Start(CancellationToken ct) {
                         var cookie = new object();
                         if (MoveStart(cookie))
                             ScheduleTask(StartInternalAsync, ct, cookie);
+                        else
+                            throw new InvalidOperationException();
                     }
                     protected virtual Task StartInternalAsync(CancellationToken ct) {
                         return Task.CompletedTask;
                     }
                     public void Stop(CancellationToken ct) {
                         var cookie = new object();
                         if (MoveStop(cookie))
                             ScheduleTask(StopAsync, ct, cookie);
+                        else
+                            throw new InvalidOperationException();
                     }
                     async Task StopAsync(CancellationToken ct) {
                         m_current.Cancel();
                         await Completion;
                         ct.ThrowIfCancellationRequested();
                         await StopInternalAsync(ct);
                     }
                     protected virtual Task StopInternalAsync(CancellationToken ct) {
                         return Task.CompletedTask;
                     }
+                    protected void Fail(Exception err) {
+                        lock(m_lock) {
+                            if (m_state != ExecutionState.Running)
+                                return;
+                            m_cookie = new object();
+                            LastError = err;
+                            State = ExecutionState.Failed;
+                        }
+                    }
                     #region state management
                     bool MoveInitialize(object cookie) {
                         lock (m_lock) {
                             if (State != ExecutionState.Created)
                                 return false;
                             State = ExecutionState.Initializing;
                             m_cookie = cookie;
                             return true;
                         }
                     }
                     bool MoveStart(object cookie) {
                         lock (m_lock) {
                             if (State != ExecutionState.Ready)
                                 return false;
                             State = ExecutionState.Starting;
                             m_cookie = cookie;
                             return true;
                         }
                     }
                     bool MoveStop(object cookie) {
                         lock (m_lock) {
                             if (State != ExecutionState.Starting && State != ExecutionState.Running)
                                 return false;
                             State = ExecutionState.Stopping;
                             m_cookie = cookie;
                             return true;
                         }
                     }
                     void MoveSuccess(object cookie) {
                         lock (m_lock) {
                             if (m_cookie != cookie)
                                 return;
                             switch (State) {
                                 case ExecutionState.Initializing:
                                     State = ExecutionState.Ready;
                                     break;
                                 case ExecutionState.Starting:
                                     State = ExecutionState.Running;
                                     break;
                                 case ExecutionState.Stopping:
                                     State = ExecutionState.Stopped;
                                     break;
                             }
                         }
                     }
                     void MoveFailed(Exception err, object cookie) {
                         lock (m_lock) {
                             if (m_cookie != cookie)
                                 return;
                             LastError = err;
                             State = ExecutionState.Failed;
                         }
                     }
+                    void ScheduleTask(Func<CancellationToken, Task> next, CancellationToken ct, object cookie) {
-                    protected async void ScheduleTask(Func<CancellationToken, Task> next, CancellationToken ct, object cookie) {
+                        m_current = AsyncOperationDescriptor.Create(async (x) => {
-                        try {
+                            try {
-                            m_current = AsyncOperationDescriptor.Create(next, ct);
+                                await next(x);
-                            await m_current.Task;
+                                MoveSuccess(cookie);
-                            MoveSuccess(cookie);
+                            } catch (Exception e) {
-                        } catch (Exception e) {
+                                MoveFailed(e, cookie);
-                            MoveFailed(e, cookie);
+                        }, ct);
                     }
                     #endregion
                 }
             }

Implab/Components/App.cs removed 0 -25

NO CONTENT: file was removed

Implab/Components/ComponentContainer.cs removed 0 -130

NO CONTENT: file was removed

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages