Make JsPool generic to allow for using other engines directly in the future

Author: Daniel15

src/JSPool/IJavaScriptEngineSwitcherPool.cs

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2016 Daniel Lo Nigro (Daniel15)
+ * 
+ * This source code is licensed under the BSD-style license found in the 
+ * LICENSE file in the root directory of this source tree. 
+ */
+
+using JavaScriptEngineSwitcher.Core;
+
+namespace JSPool
+{
+	/// <summary>
+	/// Handles acquiring JavaScript engines from a shared pool. This class is thread safe.
+	/// </summary>
+	public interface IJsPool : IJsPool<IJsEngine>
+	{
+	}
+}

src/JSPool/IJsPool.cs

@@ -1,20 +1,19 @@
 /*
- * Copyright (c) 2014 Daniel Lo Nigro (Daniel15)
+ * Copyright (c) 2014-2016 Daniel Lo Nigro (Daniel15)
  * 
  * This source code is licensed under the BSD-style license found in the 
  * LICENSE file in the root directory of this source tree. 
  */
 
 using System;
-using JavaScriptEngineSwitcher.Core;
 using JSPool.Exceptions;
 
 namespace JSPool
 {
 	/// <summary>
 	/// Handles acquiring JavaScript engines from a shared pool. This class is thread safe.
 	/// </summary>
-	public interface IJsPool : IDisposable
+	public interface IJsPool<T> : IDisposable
 	{
 		/// <summary>
 		/// Gets an engine from the pool. This engine should be returned to the pool via
@@ -32,13 +31,13 @@ public interface IJsPool : IDisposable
 		/// <exception cref="JsPoolExhaustedException">
 		/// Thrown if no engines are available in the pool within the provided timeout period.
 		/// </exception>
-		IJsEngine GetEngine(TimeSpan? timeout = null);
+		T GetEngine(TimeSpan? timeout = null);
 
 		/// <summary>
 		/// Returns an engine to the pool so it can be reused
 		/// </summary>
 		/// <param name="engine">Engine to return</param>
-		void ReturnEngineToPool(IJsEngine engine);
+		void ReturnEngineToPool(T engine);
 
 		/// <summary>
 		/// Gets the total number of engines in this engine pool, including engines that are
@@ -58,7 +57,7 @@ public interface IJsPool : IDisposable
 		/// <param name="repopulateEngines">
 		/// If <c>true</c>, a new engine will be created to replace the disposed engine
 		/// </param>
-		void DisposeEngine(IJsEngine engine, bool repopulateEngines = true);
+		void DisposeEngine(T engine, bool repopulateEngines = true);
 
 		/// <summary>
 		/// Disposes all engines in this pool, and creates new engines in their place.

src/JSPool/JSPool.csproj

@@ -58,12 +58,14 @@
     <Compile Include="FileWatcher.cs" />
     <Compile Include="IFileWatcher.cs" />
     <Compile Include="IJsEngineWithOwnThread.cs" />
+    <Compile Include="IJavaScriptEngineSwitcherPool.cs" />
     <Compile Include="IJsPool.cs" />
-    <Compile Include="JsEngineExtensions.cs" />
     <Compile Include="JsEngineWithOwnThread.cs" />
-    <Compile Include="JsPool.cs" />
-    <Compile Include="JsPoolConfig.cs" />
+    <Compile Include="JavaScriptEngineSwitcherPool.cs" />
+    <Compile Include="JavaScriptEngineSwitcherPoolConfig.cs" />
     <Compile Include="Exceptions\JsPoolExhaustedException.cs" />
+    <Compile Include="JsPoolConfig.cs" />
+    <Compile Include="JsPool.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>

src/JSPool/JsEngineExtensions.cs renamed to src/JSPool/JavaScriptEngineSwitcherPool.cs

@@ -6,65 +6,78 @@
  */
 
 using System;
+using System.Diagnostics;
 using System.Reflection;
 using JavaScriptEngineSwitcher.Core;
 
 namespace JSPool
 {
 	/// <summary>
-	/// Extension methods for <see cref="IJsEngine"/>.
+	/// Handles acquiring JavaScript engines from a shared pool. This class is thread-safe.
 	/// </summary>
-	public static class JsEngineExtensions
+	[DebuggerDisplay("{DebuggerDisplay,nq}")]
+	public class JsPool : JsPool<IJsEngine>
 	{
 		private const string MSIE_TYPE = "MsieJsEngine";
 		private const string V8_TYPE = "V8JsEngine";
 
 		/// <summary>
-		/// Determines if the specified engine can only be used on the thread it is created on.
+		/// Creates a new JavaScript engine pool
 		/// </summary>
-		/// <param name="engine">Engine</param>
-		/// <returns><c>true</c> if the engine should be confined to a single thread</returns>
-		public static bool NeedsOwnThread(this IJsEngine engine)
+		/// <param name="config">
+		/// The configuration to use. If not provided, a default configuration will be used.
+		/// </param>
+		public JsPool(JsPoolConfig config = null) 
+			: base(config ?? new JsPoolConfig())
 		{
-			// Checking MsieJsEngine as a string so we don't need to pull in an otherwise
-			// unneeded dependency on MsieJsEngine.
-			return engine.GetType().Name == MSIE_TYPE;
 		}
 
 		/// <summary>
-		/// Determines if the specified engine supports garbage collection.
+		/// Gets a factory method used to create engines.
 		/// </summary>
-		/// <param name="engine">Engine</param>
-		/// <returns><c>true</c> if the engine supports garbage collection</returns>
-		public static bool SupportsGarbageCollection(this IJsEngine engine)
+		protected override Func<IJsEngine> CreateEngineFactory()
 		{
-			return engine.GetType().Name == V8_TYPE;
+			using (var tempEngine = _config.EngineFactory())
+			{
+				if (!NeedsOwnThread(tempEngine))
+				{
+					// Engine is fine with being accessed across multiple threads, we can just
+					// return its factory directly.
+					return _config.EngineFactory;
+				}
+				// Engine needs special treatment. This is the case with the MSIE engine, which
+				// can only be accessed from the thread it was created on. In this case we need
+				// to create the engine in a separate thread and marshall the requests across.
+				return () => new JsEngineWithOwnThread(_config.EngineFactory, _cancellationTokenSource.Token);
+			}
 		}
 
 		/// <summary>
-		/// Collecs garbage in the specified engine.
+		/// Determines if the specified engine can only be used on the thread it is created on.
 		/// </summary>
-		/// <param name="engine">Engine to collect garbage in</param>
-		public static void CollectGarbage(this IJsEngine engine)
+		/// <param name="engine">Engine</param>
+		/// <returns><c>true</c> if the engine should be confined to a single thread</returns>
+		private static bool NeedsOwnThread(IJsEngine engine)
 		{
-			if (!engine.SupportsGarbageCollection())
-			{
-				throw new InvalidOperationException("Engine doesn't support garbage collection.");
-			}
-
-			V8CollectGarbage(engine);
+			// Checking MsieJsEngine as a string so we don't need to pull in an otherwise
+			// unneeded dependency on MsieJsEngine.
+			return engine.GetType().Name == MSIE_TYPE;
 		}
 
 		#region V8 Garbage Collection implementation
 		private static FieldInfo _innerEngineField;
 		private static MethodInfo _collectGarbageMethod;
-
 		/// <summary>
-		/// Collects garbage in the specified V8 engine.
+		/// Runs garbage collection for the specified engine
 		/// </summary>
 		/// <param name="engine"></param>
-		private static void V8CollectGarbage(IJsEngine engine)
+		protected override void CollectGarbage(IJsEngine engine)
 		{
+			if (engine.GetType().Name != V8_TYPE)
+			{
+				return;
+			}
+
 			// Since JavaScriptEngineSwitcher does not expose the inner JavaScript engine, we need
 			// to use reflection to get to it.
 			if (_innerEngineField == null)

src/JSPool/JavaScriptEngineSwitcherPoolConfig.cs

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2014-2016 Daniel Lo Nigro (Daniel15)
+ * 
+ * This source code is licensed under the BSD-style license found in the 
+ * LICENSE file in the root directory of this source tree. 
+ */
+
+using JavaScriptEngineSwitcher.Core;
+
+namespace JSPool
+{
+	/// <summary>
+	/// Contains the configuration information for JSPool
+	/// </summary>
+	public class JsPoolConfig : JsPoolConfig<IJsEngine>
+	{
+		/// <summary>
+		/// Creates a new JavaScript pool configuration. Default values will be set automatically.
+		/// </summary>
+		public JsPoolConfig()
+		{
+			EngineFactory = JsEngineSwitcher.Current.CreateDefaultJsEngineInstance;
+		}
+	}
+}

src/JSPool/JsPool.cs

@@ -10,7 +10,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading;
-using JavaScriptEngineSwitcher.Core;
 using JSPool.Exceptions;
 
 namespace JSPool
@@ -19,24 +18,24 @@ namespace JSPool
 	/// Handles acquiring JavaScript engines from a shared pool. This class is thread-safe.
 	/// </summary>
 	[DebuggerDisplay("{DebuggerDisplay,nq}")]
-	public class JsPool : IJsPool
+	public class JsPool<T> : IJsPool<T>
 	{
 		/// <summary>
 		/// Configuration for this engine pool.
 		/// </summary>
-		protected readonly JsPoolConfig _config;
+		protected readonly JsPoolConfig<T> _config;
 		/// <summary>
 		/// Engines that are currently available for use.
 		/// </summary>
-		protected readonly BlockingCollection<IJsEngine> _availableEngines = new BlockingCollection<IJsEngine>();
+		protected readonly BlockingCollection<T> _availableEngines = new BlockingCollection<T>();
 		/// <summary>
 		/// Metadata for the engines. Total number of engines that have been created is reflected in its Count.
 		/// </summary>
-		protected readonly IDictionary<IJsEngine, EngineMetadata> _metadata = new ConcurrentDictionary<IJsEngine, EngineMetadata>();
+		protected readonly IDictionary<T, EngineMetadata> _metadata = new ConcurrentDictionary<T, EngineMetadata>();
 		/// <summary>
 		/// Factory method used to create engines.
 		/// </summary>
-		protected readonly Func<IJsEngine> _engineFactory;
+		protected readonly Func<T> _engineFactory;
 		/// <summary>
 		/// Handles watching for changes to files, to recycle the engines if any related files change.
 		/// </summary>
@@ -62,9 +61,9 @@ public class JsPool : IJsPool
 		/// <param name="config">
 		/// The configuration to use. If not provided, a default configuration will be used.
 		/// </param>
-		public JsPool(JsPoolConfig config = null)
+		public JsPool(JsPoolConfig<T> config)
 		{
-			_config = config ?? new JsPoolConfig();
+			_config = config;
 			_engineFactory = CreateEngineFactory();
 			PopulateEngines();
 			InitializeWatcher();
@@ -73,21 +72,9 @@ public JsPool(JsPoolConfig config = null)
 		/// <summary>
 		/// Gets a factory method used to create engines.
 		/// </summary>
-		protected virtual Func<IJsEngine> CreateEngineFactory()
+		protected virtual Func<T> CreateEngineFactory()
 		{
-			using (var tempEngine = _config.EngineFactory())
-			{
-				if (!tempEngine.NeedsOwnThread())
-				{
-					// Engine is fine with being accessed across multiple threads, we can just
-					// return its factory directly.
-					return _config.EngineFactory;
-				}
-				// Engine needs special treatment. This is the case with the MSIE engine, which
-				// can only be accessed from the thread it was created on. In this case we need
-				// to create the engine in a separate thread and marshall the requests across.
-				return () => new JsEngineWithOwnThread(_config.EngineFactory, _cancellationTokenSource.Token);
-			}
+			return _config.EngineFactory;
 		}
 
 		/// <summary>
@@ -122,7 +109,7 @@ protected virtual void PopulateEngines()
 		/// <summary>
 		/// Creates a new JavaScript engine and adds it to the list of all available engines.
 		/// </summary>
-		protected virtual IJsEngine CreateEngine()
+		protected virtual T CreateEngine()
 		{
 			var engine = _engineFactory();
 			_config.Initializer(engine);
@@ -146,9 +133,9 @@ protected virtual IJsEngine CreateEngine()
 		/// <exception cref="JsPoolExhaustedException">
 		/// Thrown if no engines are available in the pool within the provided timeout period.
 		/// </exception>
-		public virtual IJsEngine GetEngine(TimeSpan? timeout = null)
+		public virtual T GetEngine(TimeSpan? timeout = null)
 		{
-			IJsEngine engine;
+			T engine;
 
 			// First see if a pooled engine is immediately available
 			if (_availableEngines.TryTake(out engine))
@@ -183,7 +170,7 @@ public virtual IJsEngine GetEngine(TimeSpan? timeout = null)
 		/// Marks the specified engine as "in use"
 		/// </summary>
 		/// <param name="engine"></param>
-		private IJsEngine TakeEngine(IJsEngine engine)
+		private T TakeEngine(T engine)
 		{
 			var metadata = _metadata[engine];
 			metadata.InUse = true;
@@ -195,15 +182,18 @@ private IJsEngine TakeEngine(IJsEngine engine)
 		/// Returns an engine to the pool so it can be reused
 		/// </summary>
 		/// <param name="engine">Engine to return</param>
-		public virtual void ReturnEngineToPool(IJsEngine engine)
+		public virtual void ReturnEngineToPool(T engine)
 		{
 			EngineMetadata metadata;
 			if (!_metadata.TryGetValue(engine, out metadata))
 			{
 				// This engine was from another pool. This could happen if a pool is recycled
 				// and replaced with a different one (like what ReactJS.NET does when any 
 				// loaded files change). Let's just pretend we never saw it.
-				engine.Dispose();
+				if (engine is IDisposable)
+				{
+					((IDisposable)engine).Dispose();
+				}
 				return;
 			}
 
@@ -218,11 +208,10 @@ public virtual void ReturnEngineToPool(IJsEngine engine)
 
 			if (
 				_config.GarbageCollectionInterval > 0 &&
-				usageCount % _config.GarbageCollectionInterval == 0 &&
-				engine.SupportsGarbageCollection()
+				metadata.UsageCount % _config.GarbageCollectionInterval == 0
 			)
 			{
-				engine.CollectGarbage();
+				CollectGarbage(engine);
 			}
 
 			_availableEngines.Add(engine);
@@ -235,9 +224,12 @@ public virtual void ReturnEngineToPool(IJsEngine engine)
 		/// <param name="repopulateEngines">
 		/// If <c>true</c>, a new engine will be created to replace the disposed engine
 		/// </param>
-		public virtual void DisposeEngine(IJsEngine engine, bool repopulateEngines = true)
+		public virtual void DisposeEngine(T engine, bool repopulateEngines = true)
 		{
-			engine.Dispose();
+			if (engine is IDisposable)
+			{
+				((IDisposable)engine).Dispose();
+			}
 			_metadata.Remove(engine);
 
 			if (repopulateEngines)
@@ -254,7 +246,7 @@ public virtual void DisposeEngine(IJsEngine engine, bool repopulateEngines = tru
 		/// </summary>
 		protected virtual void DisposeAllEngines()
 		{
-			IJsEngine engine;
+			T engine;
 			while (_availableEngines.TryTake(out engine))
 			{
 				DisposeEngine(engine, repopulateEngines: false);
@@ -290,6 +282,15 @@ public virtual void Dispose()
 				_fileWatcher.Dispose();
 			}
 		}
+		
+		/// <summary>
+		/// Runs garbage collection for the specified engine
+		/// </summary>
+		/// <param name="engine"></param>
+		protected virtual void CollectGarbage(T engine)
+		{
+			// No-op by default
+		}
 
 		#region Statistics and debugging
 		/// <summary>