User/jmaxson/loading fixes

src/Microsoft.Performance.SDK.Runtime.NetCoreApp/Plugins/PluginsLoader.cs

@@ -109,7 +109,7 @@ public PluginsLoader(
             // The constructor for this object hooks up the repository to the extension provider
             // (the ExtensionDiscovery in this case). We do not need to hold onto this object
             // explicitly, only call its constructor.
-            new DataExtensionReflector(this.extensionDiscovery, extensionRepository);
+            new DataExtensionReflector(this.extensionDiscovery, extensionRepository, logger);
 
             this.isDisposed = false;
             this.logger = logger;
@@ -254,7 +254,7 @@ public bool TryLoadPlugins(IEnumerable<string> directories, out IDictionary<stri
             {
                 Guard.NotNull(dir, nameof(directories));
             }
-            
+
             failed = new Dictionary<string, ErrorInfo>();
 
             if (!directories.Any())
@@ -280,21 +280,21 @@ public bool TryLoadPlugins(IEnumerable<string> directories, out IDictionary<stri
                         failed.Add(dir, emptyErrorInfo);
                         continue;
                     }
-                    
+
                     if (!this.extensionDiscovery.ProcessAssemblies(dir, out var error))
                     {
                         failed.Add(dir, error);
                         continue;
                     }
                 }
-                
+
                 // If nothing was able to be loaded above, skip finalizing 
                 if (this.extensionRoot.IsLoaded)
                 {
                     // TODO (#223): this does redundant work re-finalizing processing sources
                     // loaded by previous calls to this method. The extension repository
                     // should get refactored to avoid this redundant work.
-                    
+
                     this.extensionRoot.FinalizeDataExtensions();
                 }
 

src/Microsoft.Performance.SDK.Runtime.Tests/Extensibility/TableExtensionReferenceTests.cs

@@ -22,6 +22,7 @@ public void WhenDisposed_EverthingThrows()
             {
                 var result = TableExtensionReference.TryCreateReference(
                     typeof(TestTableExtension),
+                    Logger.Null,
                     out sut);
 
                 Assert.IsTrue(result);
@@ -51,6 +52,7 @@ public void CanDisposeMultipleTimes()
             {
                 var result = TableExtensionReference.TryCreateReference(
                     typeof(TestTableExtension),
+                    Logger.Null,
                     out sut);
 
                 Assert.IsTrue(result);

src/Microsoft.Performance.SDK.Runtime/Discovery/ReflectionProcessingSourceCatalog.cs

@@ -1,10 +1,10 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-using Microsoft.Performance.SDK.Processing;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using Microsoft.Performance.SDK.Processing;
 
 namespace Microsoft.Performance.SDK.Runtime.Discovery
 {
@@ -133,14 +133,26 @@ private set
         public void ProcessType(Type type, string sourceName)
         {
             this.ThrowIfDisposed();
+
+            if (this.loadedDataSources.ContainsKey(type))
+            {
+                // an assembly might exist in multiple folders and we get the same type multiple times.
+                // do not attempt to recreate the reference in this case
+                return;
+            }
+
             if (this.referenceFactory(type, out ProcessingSourceReference reference))
             {
                 Debug.Assert(reference != null);
                 try
                 {
                     this.loadedDataSources.Add(type, reference);
                 }
-                catch { }
+                catch
+                {
+                    // if we were unable to add this reference, clean it up
+                    reference.TryDispose();
+                }
             }
         }
 

src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataCookers/CompositeDataCookerReference.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Diagnostics;
 using Microsoft.Performance.SDK.Extensibility;
 using Microsoft.Performance.SDK.Extensibility.DataCooking;
 using Microsoft.Performance.SDK.Processing;
@@ -41,8 +42,8 @@ private CompositeDataCookerReference(Type type, ILogger logger)
             {
                 this.InitializeDescriptorData(instance);
             }
-        }       
-        
+        }
+
         /// <summary>
         ///     Tries to create an instance of <see cref="ICompositeDataCookerReference"/> based on the
         ///     <paramref name="candidateType"/>.
@@ -71,7 +72,7 @@ internal static bool TryCreateReference(
         {
             return TryCreateReference(
                 candidateType,
-                Runtime.Logger.Create<CompositeDataCookerReference>(),
+                Microsoft.Performance.SDK.Runtime.Logger.Null,
                 out reference);
         }
 
@@ -105,8 +106,8 @@ internal static bool TryCreateReference(
             ILogger logger,
             out ICompositeDataCookerReference reference)
         {
-            Guard.NotNull(candidateType, nameof(candidateType));
-            Guard.NotNull(logger, nameof(logger));
+            Debug.Assert(candidateType != null, $"{nameof(candidateType)} cannot be null.");
+            Debug.Assert(logger != null, $"{nameof(logger)} cannot be null.");
 
             reference = null;
 

src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataCookers/SourceDataCookerReference.cs

@@ -10,7 +10,6 @@
 using Microsoft.Performance.SDK.Extensibility.DataCooking;
 using Microsoft.Performance.SDK.Extensibility.DataCooking.SourceDataCooking;
 using Microsoft.Performance.SDK.Processing;
-using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataProcessors;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Dependency;
 
 namespace Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataCookers
@@ -141,7 +140,7 @@ internal static bool TryCreateReference(
         {
             return TryCreateReference(
                 candidateType,
-                Runtime.Logger.Create<SourceDataCookerReference>(),
+                Runtime.Logger.Null,
                 out reference);
         }
 
@@ -176,7 +175,8 @@ internal static bool TryCreateReference(
             ILogger logger,
             out ISourceDataCookerReference reference)
         {
-            Guard.NotNull(candidateType, nameof(candidateType));
+            Debug.Assert(candidateType != null, $"{nameof(candidateType)} cannot be null.");
+            Debug.Assert(logger != null, $"{nameof(logger)} cannot be null.");
 
             reference = null;
 
@@ -202,7 +202,7 @@ internal static bool TryCreateReference(
             // There must be an empty, public constructor
             if (!candidateType.TryGetEmptyPublicConstructor(out var constructor))
             {
-                Console.Error.WriteLine(
+                logger.Error(
                     $"Warning: type {candidateType} seems to be a data cooker, but is missing an empty public " +
                     "constructor.");
                 return false;

src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataExtensionFactory.cs

@@ -7,7 +7,6 @@
 using Microsoft.Performance.SDK.Extensibility.SourceParsing;
 using Microsoft.Performance.SDK.Processing;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataCookers;
-using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataProcessors;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Repository;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Tables;
 
@@ -19,13 +18,13 @@ namespace Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions
     public class DataExtensionFactory
         : IDataExtensionFactory
     {
-        private static readonly DataExtensionRepository SingletonRepository 
+        private static readonly DataExtensionRepository SingletonRepository
             = new DataExtensionRepository();
 
         /// <summary>
         ///     Gets a singleton instance of this class.
         /// </summary>
-        public IDataExtensionRepositoryBuilder SingletonDataExtensionRepository 
+        public IDataExtensionRepositoryBuilder SingletonDataExtensionRepository
             => DataExtensionFactory.SingletonRepository;
 
         /// <summary>
@@ -43,10 +42,34 @@ public IDataExtensionRepositoryBuilder SingletonDataExtensionRepository
         public bool TryCreateSourceDataCookerReference(
             Type candidateType,
             out ISourceDataCookerReference reference)
+        {
+            return TryCreateSourceDataCookerReference(candidateType, Logger.Null, out reference);
+        }
+
+        /// <summary>
+        ///     Generate a source data cooker reference from a given type.
+        /// </summary>
+        /// <param name="candidateType">
+        ///     Data extension type.
+        /// </param>
+        /// <param name="reference">
+        ///     Data extension reference.
+        /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <returns>
+        ///     <c>true</c> if succeeded, <c>false</c> otherwise.
+        /// </returns>
+        public bool TryCreateSourceDataCookerReference(
+            Type candidateType,
+            ILogger logger,
+            out ISourceDataCookerReference reference)
         {
             Guard.NotNull(candidateType, nameof(candidateType));
+            Guard.NotNull(logger, nameof(logger));
 
-            return SourceDataCookerReference.TryCreateReference(candidateType, out reference);
+            return SourceDataCookerReference.TryCreateReference(candidateType, logger, out reference);
         }
 
         /// <summary>
@@ -64,10 +87,34 @@ public bool TryCreateSourceDataCookerReference(
         public bool TryCreateCompositeDataCookerReference(
             Type candidateType,
             out ICompositeDataCookerReference reference)
+        {
+            return TryCreateCompositeDataCookerReference(candidateType, Logger.Null, out reference);
+        }
+
+        /// <summary>
+        ///     Generate a composite data cooker reference from a given type.
+        /// </summary>
+        /// <param name="candidateType">
+        ///     Data extension type.
+        /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <param name="reference">
+        ///     Data extension reference.
+        /// </param>
+        /// <returns>
+        ///     <c>true</c> if succeeded, <c>false</c> otherwise.
+        /// </returns>
+        public bool TryCreateCompositeDataCookerReference(
+            Type candidateType,
+            ILogger logger,
+            out ICompositeDataCookerReference reference)
         {
             Guard.NotNull(candidateType, nameof(candidateType));
+            Guard.NotNull(logger, nameof(logger));
 
-            return CompositeDataCookerReference.TryCreateReference(candidateType, out reference);
+            return CompositeDataCookerReference.TryCreateReference(candidateType, logger, out reference);
         }
 
         // TODO: __SDK_DP__
@@ -108,10 +155,34 @@ public bool TryCreateCompositeDataCookerReference(
         public bool TryCreateTableReference(
             Type candidateType,
             out ITableExtensionReference reference)
+        {
+            return TryCreateTableReference(candidateType, Logger.Null, out reference);
+        }
+
+        /// <summary>
+        ///     Generate a table reference from a given type.
+        /// </summary>
+        /// <param name="candidateType">
+        ///     Data extension type.
+        /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <param name="reference">
+        ///     Data extension reference.
+        /// </param>
+        /// <returns>
+        ///     <c>true</c> if succeeded, <c>false</c> otherwise.
+        /// </returns>
+        public bool TryCreateTableReference(
+            Type candidateType,
+            ILogger logger,
+            out ITableExtensionReference reference)
         {
             Guard.NotNull(candidateType, nameof(candidateType));
+            Guard.NotNull(logger, nameof(logger));
 
-            return TableExtensionReference.TryCreateReference(candidateType, out reference);
+            return TableExtensionReference.TryCreateReference(candidateType, logger, out reference);
         }
 
         /// <summary>

src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataExtensionReflector.cs

@@ -1,13 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System;
+using System.Diagnostics;
+using Microsoft.Performance.SDK.Processing;
 using Microsoft.Performance.SDK.Runtime.Discovery;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataCookers;
-using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataProcessors;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Repository;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Tables;
-using System;
-using System.Diagnostics;
 
 namespace Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions
 {
@@ -18,6 +18,7 @@ public class DataExtensionReflector
         : IExtensionTypeObserver
     {
         private readonly IDataExtensionRepositoryBuilder repoBuilder;
+        private readonly ILogger logger;
 
         /// <summary>
         ///     Initializes a new instance of the DataExtensionReflector class.
@@ -28,33 +29,41 @@ public class DataExtensionReflector
         /// <param name="repoBuilder">
         ///     Provides an output to store discovered extensions.
         /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
         public DataExtensionReflector(
             IExtensionTypeProvider extensionProvider,
-            IDataExtensionRepositoryBuilder repoBuilder)
+            IDataExtensionRepositoryBuilder repoBuilder,
+            ILogger logger)
         {
+            Guard.NotNull(logger, nameof(logger));
+
             this.repoBuilder = repoBuilder;
+            this.logger = logger;
+
             extensionProvider.RegisterTypeConsumer(this);
         }
 
         /// <inheritdoc />
         public void ProcessType(Type type, string sourceName)
         {
             // Find source data cookers
-            if (SourceDataCookerReference.TryCreateReference(type, out var sourceDataCookerReference))
+            if (SourceDataCookerReference.TryCreateReference(type, this.logger, out var sourceDataCookerReference))
             {
                 Debug.Assert(sourceDataCookerReference != null);
                 this.repoBuilder.AddSourceDataCookerReference(sourceDataCookerReference);
             }
 
             // Find composite data cookers
-            if (CompositeDataCookerReference.TryCreateReference(type, out var compositeDataCookerReference))
+            if (CompositeDataCookerReference.TryCreateReference(type, this.logger, out var compositeDataCookerReference))
             {
                 Debug.Assert(compositeDataCookerReference != null);
                 this.repoBuilder.AddCompositeDataCookerReference(compositeDataCookerReference);
             }
 
             // Find tables
-            if (TableExtensionReference.TryCreateReference(type, out var dataExtensionReference))
+            if (TableExtensionReference.TryCreateReference(type, this.logger, out var dataExtensionReference))
             {
                 Debug.Assert(dataExtensionReference != null);
                 this.repoBuilder.AddTableExtensionReference(dataExtensionReference);