Merge pull request #9 from navtech-io/develop

Develop

Author: rajeshjn

build/Build.cs

@@ -125,7 +125,6 @@ class Build : NukeBuild
                 .AddProperty("PackageLicenseExpression", "Apache-2.0")
                 .AddProperty("PackageIcon", @"PackageIcon.png")
                 .SetIncludeSymbols(true)
-                .SetVersion("0.1.0-beta06")
                 .SetDescription("Build dynamic rules and workflows using script")
                 .SetPackageTags("Simpleflow.NET Workflow RuleEngine DynamicExpressionEvaluator")
                 .SetNoDependencies(true)

src/Simpleflow/CacheOptions.cs

@@ -20,9 +20,10 @@ public class CacheOptions
         public System.DateTimeOffset? AbsoluteExpiration { get; set; }
 
         /// <summary>
-        /// Gets or sets hashing algorithm to identify script compiled object uniquely
+        /// Gets or sets hashing algorithm to identify script compiled object uniquely. This method is used when no script id specified.
         /// Check available hash algorithms and names here: https://docs.microsoft.com/en-us/dotnet/api/system.security.cryptography.hashalgorithm.create?view=net-6.0
         /// </summary>
         public string HashingAlgToIdentifyScriptUniquely { get; set; } = "MD5";
+
     }
 }

src/Simpleflow/FlowContext.cs

@@ -2,13 +2,11 @@
 // See License in the project root for license information.
 
 using System;
-using System.Dynamic;
 
 namespace Simpleflow
 {
     /// <summary>
-    /// A <see cref="FlowContext"/> instance represents input, output, and which has
-    /// special property "Items" can be used by middleware to share data among.
+    /// A <see cref="FlowContext&lt;TArg&gt;"/> instance represents input and output.
     /// </summary>
     public sealed class FlowContext<TArg>
     {
@@ -36,16 +34,26 @@ public sealed class FlowContext<TArg>
         public FlowOutput Output { get; } = new FlowOutput(); 
 
         /// <summary>
-        /// Gets trace to verify the executed middleware
+        /// Gets trace to verify the middleware info
         /// </summary>
-        public SimpleflowTrace Trace { get; } = new SimpleflowTrace();
+        public SimpleflowTrace Trace { get; private set; } 
 
+        
         /// <summary>
         /// 
         /// </summary>
         public FlowInternals Internals { get; } = new FlowInternals();
 
-        
+        /// <summary>
+        /// 
+        /// </summary>
+        public void EnableTrace()
+        {
+            Trace = new SimpleflowTrace();
+        }
+
+
+
         /// <summary>
         /// 
         /// </summary>
@@ -55,11 +63,6 @@ public class FlowInternals
             /// 
             /// </summary>
             public Action<FlowInput<TArg>, FlowOutput, ScriptHelperContext> CompiledScript { get; set; }
-
-            /// <summary>
-            /// 
-            /// </summary>
-            public dynamic Tag { get; } = new ExpandoObject();
         }
     }
 }

src/Simpleflow/FlowContextOptions.cs

@@ -17,5 +17,7 @@ public class FlowContextOptions : FlowOptions, IContextOptions
         /// </summary>
         public string Id { get; set; }
 
+        /// <inheritdoc/>
+        public bool ResetCache { get; set; }
     }
 }

src/Simpleflow/FunctionRegister.cs

@@ -4,8 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Net.Http.Headers;
-using Simpleflow.Functions;
+
 using Simpleflow.Exceptions;
 
 namespace Simpleflow
@@ -121,7 +120,7 @@ public Delegate GetFunction(string name)
         /// <param name="name"></param>
         /// <returns></returns>
 
-        public bool? IsFunctionAvailableInClass(string name)
+        private bool? IsFunctionAvailableInClass(string name)
         {
             if (_bitmapIndex.ContainsKey(name))
             {

src/Simpleflow/IContextOptions.cs

@@ -12,5 +12,10 @@ public interface IContextOptions : IOptions
         /// Gets unique id of the script
         /// </summary>
         string Id { get; }
+
+        /// <summary>
+        /// Reset cache allows to remove the item from cache if exists and add it once its compiled.
+        /// </summary>
+        public bool ResetCache { get; set; }
     }
 }

src/Simpleflow/Services/CacheService.cs

@@ -47,41 +47,25 @@ public CacheService() : this(new CacheOptions())
         /// <inheritdoc />
         public void Run<TArg>(FlowContext<TArg> context, NextPipelineService<TArg> next)
         {
+            // Add trace for debugging
+            context.Trace?.CreateNewTracePoint(nameof(CacheService));
+
             // Create unique id for script to identify in cache store
-            var id = string.IsNullOrWhiteSpace(context.Options?.Id) ?  
+            var id = string.IsNullOrWhiteSpace(context.Options?.Id) ?
                             GetScriptUniqueId(context.Options?.CacheOptions, context.Script) : context.Options.Id;
 
-            // GetFlowContextOptionsId helps to identify script uniquely along with options
-            // in order to allow or deny functions 
-            if (context.Options != null)
-            {
-                id += "_" + GetFlowContextOptionsId(context.Options);
-            }
-
-            context.Trace.Write($"Cache-Key {id}");
+            context.Trace?.Write($"Cache-Key {id}");
 
-            // Get compiled script from cache
-            var compiledScript = _cache.Get< Action<FlowInput<TArg>, FlowOutput, ScriptHelperContext>>(key: id);
-            if (compiledScript != null)
-            {
-                context.Trace.Write($"Read from cache {id} - Succeeded");
-                context.Internals.CompiledScript = compiledScript;
-            }
+            // Get compiled script from cache and set it to context in order to avoid recompilation
+            var isAvailableInCache = GetAndSetToContextTheCompiledScript(context, id);
 
             // Invoke next service in pipeline
             next?.Invoke(context);
 
-            // Cache compiled script
-            if (compiledScript == null && context.Internals.CompiledScript != null)
+            // Cache the compiled script
+            if (!isAvailableInCache && context.Internals.CompiledScript != null)
             {
-                _cache.Set(key: id,
-                           value: context.Internals.CompiledScript,
-                           options: new MemoryCacheEntryOptions { 
-                                AbsoluteExpiration = context.Options?.CacheOptions?.AbsoluteExpiration ?? _cacheOptions.AbsoluteExpiration,
-                                SlidingExpiration = context.Options?.CacheOptions?.SlidingExpiration ??  _cacheOptions.SlidingExpiration
-                           }); 
-
-                context.Trace.Write($"Saved into cache {id} - Succeeded");
+                StoreIntoCacheCompiledScript(context, id);
             }
         }
 
@@ -98,34 +82,44 @@ protected virtual string GetScriptUniqueId(CacheOptions contextCacheOptions, str
             return System.Convert.ToBase64String(sha1.ComputeHash(Encoding.UTF8.GetBytes(script)));
         }
 
-        private string GetFlowContextOptionsId(IContextOptions options)
-        {
-            if (
-                //options.AllowArgumentToMutate == false &&
-                (options.AllowFunctions == null || options.AllowFunctions.Length == 0)
-                && (options.DenyFunctions == null  || options.DenyFunctions.Length == 0)
-                )
-            {
-                return string.Empty;
-            }
 
-            StringBuilder sb = new StringBuilder();
-            //sb.Append(string.Join(' ', options.AllowArgumentToMutate));
+        private void StoreIntoCacheCompiledScript<TArg>(FlowContext<TArg> context, string id)
+        {
+            _cache.Set(key: id,
+                                       value: context.Internals.CompiledScript,
+                                       options: new MemoryCacheEntryOptions
+                                       {
+                                           AbsoluteExpiration = context.Options?.CacheOptions?.AbsoluteExpiration ?? _cacheOptions.AbsoluteExpiration,
+                                           SlidingExpiration = context.Options?.CacheOptions?.SlidingExpiration ?? _cacheOptions.SlidingExpiration
+                                       });
+
+            context.Trace?.Write($"Saved into cache {id} - Succeeded");
+        }
 
-            if (options.AllowFunctions != null && options.AllowFunctions.Length > 0)
-            {
-                sb.Append("Allow"); //ensure add this to avoid collisions
-                sb.Append(string.Join(' ', options.AllowFunctions));
-            }
+        private bool GetAndSetToContextTheCompiledScript<TArg>(FlowContext<TArg> context, string id)
+        {
+            var compiledScript = _cache.Get<Action<FlowInput<TArg>, FlowOutput, ScriptHelperContext>>(key: id);
+            var isAvailableInCache = compiledScript != null;
 
-            if (options.DenyFunctions != null && options.DenyFunctions.Length > 0)
+            if (isAvailableInCache)
             {
-                sb.Append("Deny"); //ensure add this to avoid collisions
-                sb.Append(string.Join(' ', options.DenyFunctions ));
+                if (context.Options?.ResetCache ?? false)
+                {
+                    _cache.Remove(key: id);
+                    isAvailableInCache = false; // in order to save it back
+
+                    context.Trace?.Write($"Reset cache entry '{id}' - Succeeded");
+                }
+                else
+                {
+                    context.Trace?.Write($"Read from cache {id} - Succeeded");
+                    context.Internals.CompiledScript = compiledScript;
+                }
             }
 
-            return GetScriptUniqueId(options.CacheOptions, sb.ToString());
+            return isAvailableInCache;
         }
+
     }
 
 }

src/Simpleflow/Services/CompilerService.cs

@@ -29,6 +29,10 @@ public CompilerService(IFunctionRegister functionRegister, IOptions options = nu
         /// <inheritdoc />
         public void Run<TArg>(FlowContext<TArg> context, NextPipelineService<TArg> next)
         {
+
+            // Add trace for debugging
+            context.Trace?.CreateNewTracePoint(nameof(CompilerService));
+
             /* Compile if CompiledScript  is null,
                Not-null means, it might be supplied by cache service or 
                any other predecessor in pipeline.
@@ -39,16 +43,16 @@ So here we don't need to run again  */
                 var eventPublisher = new ParserEventPublisher();
                 CheckFunctionExecutionPermissions(context, eventPublisher);
 
-                context.Internals.CompiledScript = 
+                context.Internals.CompiledScript =
                     SimpleflowCompiler.Compile<TArg>(context.Script,
                                                     new FunctionRegisterCoordinator(_functionRegister, context.FunctionRegister),
                                                     eventPublisher);
 
-                context.Trace.Write("Compiled");
+                context.Trace?.Write("Compiled");
             }
             else
             {
-                context.Trace.Write("Compilation Skipped");
+                context.Trace?.Write("Compilation Skipped");
             }
 
             next?.Invoke(context);

src/Simpleflow/Services/ExecutionService.cs

@@ -11,6 +11,10 @@ public class ExecutionService : IFlowPipelineService
         /// <inheritdoc />
         public void Run<TArg>(FlowContext<TArg> context, NextPipelineService<TArg> next)
         {
+            // Add trace for debugging
+            context.Trace?.CreateNewTracePoint(nameof(ExecutionService));
+
+
             var flowInput = new FlowInput<TArg>( context.Argument, options:null );
             var scriptHelperContext = new ScriptHelperContext(context.Output);
 

src/Simpleflow/Simpleflow.cs

@@ -81,9 +81,6 @@ private void RunPipelineService<TArg>(LinkedListNode<IFlowPipelineService> servi
                     (flowInput) => RunPipelineService<TArg>(serviceNode.Next, flowInput)
                     : default(NextPipelineService<TArg>);
 
-            // Add trace for debugging
-            input.Trace.CreateNewTracePoint(serviceNode.Value.GetType().FullName);
-
             serviceNode.Value.Run(input, next);
         }
     }