1 files changed, 207 insertions, 0 deletions

diff --git a/src/tools/heat/PerformanceCategoryHarvester.cs b/src/tools/heat/PerformanceCategoryHarvester.cs
new file mode 100644
index 00000000..6be3401b
--- /dev/null
+++ b/src/tools/heat/PerformanceCategoryHarvester.cs
@@ -0,0 +1,207 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Harvesters
+{
+    using System;
+    using System.Linq;
+    using System.Diagnostics;
+    using WixToolset.Data;
+    using WixToolset.Harvesters.Data;
+    using WixToolset.Harvesters.Extensibility;
+    using Util = WixToolset.Harvesters.Serialize.Util;
+    using Wix = WixToolset.Harvesters.Serialize;
+
+    /// <summary>
+    /// Harvest WiX authoring for a file from the file system.
+    /// </summary>
+    public sealed class PerformanceCategoryHarvester : BaseHarvesterExtension
+    {
+        /// <summary>
+        /// Harvest a performance category.
+        /// </summary>
+        /// <param name="argument">The name of the performance category.</param>
+        /// <returns>A harvested performance category.</returns>
+        public override Wix.Fragment[] Harvest(string argument)
+        {
+            if (null == argument)
+            {
+                throw new ArgumentNullException("argument");
+            }
+
+            Util.PerformanceCategory perf = this.HarvestPerformanceCategory(argument);
+
+            Wix.Component component = new Wix.Component();
+            component.Id = this.Core.CreateIdentifierFromFilename(argument);
+            component.KeyPath = Wix.YesNoType.yes;
+            component.AddChild(perf);
+
+            Wix.Directory directory = new Wix.Directory();
+            directory.Id = "TARGETDIR";
+            //directory.Name = directory.Id;
+            directory.AddChild(component);
+
+            Wix.Fragment fragment = new Wix.Fragment();
+            fragment.AddChild(directory);
+
+            return new Wix.Fragment[] { fragment };
+        }
+
+        /// <summary>
+        /// Harvest a performance category.
+        /// </summary>
+        /// <param name="category">The name of the performance category.</param>
+        /// <returns>A harvested file.</returns>
+        public Util.PerformanceCategory HarvestPerformanceCategory(string category)
+        {
+            if (null == category)
+            {
+                throw new ArgumentNullException("category");
+            }
+
+            if (PerformanceCounterCategory.Exists(category))
+            {
+                Util.PerformanceCategory perfCategory = new Util.PerformanceCategory();
+
+                // Get the performance counter category and set the appropriate WiX attributes
+                PerformanceCounterCategory pcc = PerformanceCounterCategory.GetCategories().Single(c => string.Equals(c.CategoryName, category));
+                perfCategory.Id = this.Core.CreateIdentifierFromFilename(pcc.CategoryName);
+                perfCategory.Name = pcc.CategoryName;
+                perfCategory.Help = pcc.CategoryHelp;
+                if (PerformanceCounterCategoryType.MultiInstance == pcc.CategoryType)
+                {
+                    perfCategory.MultiInstance = Util.YesNoType.yes;
+                }
+
+                // If it's multi-instance, check if there are any instances and get counters from there; else we get
+                // the counters straight up. For multi-instance, GetCounters() fails if there are any instances. If there
+                // are no instances, then GetCounters(instance) can't be called since there is no instance. Instances
+                // will exist for each counter even if only one of the counters was "intialized."
+                string[] instances = pcc.GetInstanceNames();
+                bool hasInstances = instances.Length > 0;
+                PerformanceCounter[] counters = hasInstances
+                    ? pcc.GetCounters(instances.First())
+                    : pcc.GetCounters();
+
+                foreach (PerformanceCounter counter in counters)
+                {
+                    Util.PerformanceCounter perfCounter = new Util.PerformanceCounter();
+
+                    // Get the performance counter and set the appropriate WiX attributes
+                    perfCounter.Name = counter.CounterName;
+                    perfCounter.Type = this.CounterTypeToWix(counter.CounterType);
+                    perfCounter.Help = counter.CounterHelp;
+
+                    perfCategory.AddChild(perfCounter);
+                }
+
+                return perfCategory;
+            }
+            else
+            {
+                throw new WixException(HarvesterErrors.PerformanceCategoryNotFound(category));
+            }
+        }
+
+        /// <summary>
+        /// Get the WiX performance counter type.
+        /// </summary>
+        /// <param name="pct">The performance counter value to get.</param>
+        /// <returns>The WiX performance counter type.</returns>
+        private Util.PerformanceCounterTypesType CounterTypeToWix(PerformanceCounterType pct)
+        {
+            Util.PerformanceCounterTypesType type;
+
+            switch (pct)
+            {
+                case PerformanceCounterType.AverageBase:
+                    type = Util.PerformanceCounterTypesType.averageBase;
+                    break;
+                case PerformanceCounterType.AverageCount64:
+                    type = Util.PerformanceCounterTypesType.averageCount64;
+                    break;
+                case PerformanceCounterType.AverageTimer32:
+                    type = Util.PerformanceCounterTypesType.averageTimer32;
+                    break;
+                case PerformanceCounterType.CounterDelta32:
+                    type = Util.PerformanceCounterTypesType.counterDelta32;
+                    break;
+                case PerformanceCounterType.CounterTimerInverse:
+                    type = Util.PerformanceCounterTypesType.counterTimerInverse;
+                    break;
+                case PerformanceCounterType.SampleFraction:
+                    type = Util.PerformanceCounterTypesType.sampleFraction;
+                    break;
+                case PerformanceCounterType.Timer100Ns:
+                    type = Util.PerformanceCounterTypesType.timer100Ns;
+                    break;
+                case PerformanceCounterType.CounterTimer:
+                    type = Util.PerformanceCounterTypesType.counterTimer;
+                    break;
+                case PerformanceCounterType.RawFraction:
+                    type = Util.PerformanceCounterTypesType.rawFraction;
+                    break;
+                case PerformanceCounterType.Timer100NsInverse:
+                    type = Util.PerformanceCounterTypesType.timer100NsInverse;
+                    break;
+                case PerformanceCounterType.CounterMultiTimer:
+                    type = Util.PerformanceCounterTypesType.counterMultiTimer;
+                    break;
+                case PerformanceCounterType.CounterMultiTimer100Ns:
+                    type = Util.PerformanceCounterTypesType.counterMultiTimer100Ns;
+                    break;
+                case PerformanceCounterType.CounterMultiTimerInverse:
+                    type = Util.PerformanceCounterTypesType.counterMultiTimerInverse;
+                    break;
+                case PerformanceCounterType.CounterMultiTimer100NsInverse:
+                    type = Util.PerformanceCounterTypesType.counterMultiTimer100NsInverse;
+                    break;
+                case PerformanceCounterType.ElapsedTime:
+                    type = Util.PerformanceCounterTypesType.elapsedTime;
+                    break;
+                case PerformanceCounterType.SampleBase:
+                    type = Util.PerformanceCounterTypesType.sampleBase;
+                    break;
+                case PerformanceCounterType.RawBase:
+                    type = Util.PerformanceCounterTypesType.rawBase;
+                    break;
+                case PerformanceCounterType.CounterMultiBase:
+                    type = Util.PerformanceCounterTypesType.counterMultiBase;
+                    break;
+                case PerformanceCounterType.RateOfCountsPerSecond64:
+                    type = Util.PerformanceCounterTypesType.rateOfCountsPerSecond64;
+                    break;
+                case PerformanceCounterType.RateOfCountsPerSecond32:
+                    type = Util.PerformanceCounterTypesType.rateOfCountsPerSecond32;
+                    break;
+                case PerformanceCounterType.CountPerTimeInterval64:
+                    type = Util.PerformanceCounterTypesType.countPerTimeInterval64;
+                    break;
+                case PerformanceCounterType.CountPerTimeInterval32:
+                    type = Util.PerformanceCounterTypesType.countPerTimeInterval32;
+                    break;
+                case PerformanceCounterType.SampleCounter:
+                    type = Util.PerformanceCounterTypesType.sampleCounter;
+                    break;
+                case PerformanceCounterType.CounterDelta64:
+                    type = Util.PerformanceCounterTypesType.counterDelta64;
+                    break;
+                case PerformanceCounterType.NumberOfItems64:
+                    type = Util.PerformanceCounterTypesType.numberOfItems64;
+                    break;
+                case PerformanceCounterType.NumberOfItems32:
+                    type = Util.PerformanceCounterTypesType.numberOfItems32;
+                    break;
+                case PerformanceCounterType.NumberOfItemsHEX64:
+                    type = Util.PerformanceCounterTypesType.numberOfItemsHEX64;
+                    break;
+                case PerformanceCounterType.NumberOfItemsHEX32:
+                    type = Util.PerformanceCounterTypesType.numberOfItemsHEX32;
+                    break;
+                default:
+                    throw new WixException(HarvesterErrors.UnsupportedPerformanceCounterType(pct.ToString()));
+            }
+
+            return type;
+        }
+    }
+}