Create recording controller as a result of instrumentation

Mohammad Dehghan · Mohammad Dehghan · commit ec2165f4c6d1 · 2020-12-30T07:38:26.000+03:30
This successfully encapsulates creating the recording controller and
hides implementation details about Runtime Config file.
diff --git a/SG.CodeCoverage.TestConsole/Program.cs b/SG.CodeCoverage.TestConsole/Program.cs
@@ -16,24 +16,9 @@ static void Main()
             var tester = new InstrumenterTester();
             tester.InstrumentSampleProject();
             tester.RunSomeCode();
-            var visitedFiles = tester.GetVisitedFiles();
-            Console.WriteLine(visitedFiles.Count);
-        }
-
-        static void InstrumentPath(string dir, string backupFolder, string filePattern)
-        {
-            var mapFilePath = Path.Combine(dir, "map.json");
-            var filesToInstrument = Directory
-                    .GetFiles(dir, filePattern)
-                    .ToList();
-            var options = new InstrumentationOptions(filesToInstrument, new[] { dir }, dir, 12398);
-            var instrumenter = new Instrumenter(options, mapFilePath, null)
-            {
-                BackupFolder = backupFolder,
-                RecorderLogFilePath = Path.Combine(dir, "CodeCoverageRecorderLog.txt")
-            };
-            Directory.CreateDirectory(instrumenter.BackupFolder);
-            var map = instrumenter.Instrument();
+            var result = tester.GetCoverageResult();
+            Console.WriteLine($"Visited {result.GetVisitedSources().Count()} source files" +
+                $" and {result.GetVisitedMethods().Count()} methods.");
         }
     }
 }
diff --git a/SG.CodeCoverage.Tests.NetFx/InstrumenterTester.cs b/SG.CodeCoverage.Tests.NetFx/InstrumenterTester.cs
@@ -14,19 +14,14 @@ namespace SG.CodeCoverage.Tests
 {
     public class InstrumenterTester
     {
-        public const int PortNumber = 61238;
-        public static string DefaultOutputPath { get; }
+        public int PortNumber { get; set; } = 61238;
+        public static string DefaultOutputPath { get; } = Path.Combine(Path.GetTempPath(), "SG.CodeCoverage");
         public string OutputPath { get; }
         public string MapFilePath { get; }
-        public InstrumentationMap Map { get; private set; }
+        public IRecordingController RecordingController { get; private set; }
         public string InstrumentedAssemblyPath { get; private set; }
         private readonly ILogger _logger;
 
-        static InstrumenterTester()
-        {
-            DefaultOutputPath = Path.Combine(Path.GetTempPath(), "SG.CodeCoverage");
-        }
-
         public InstrumenterTester(ILogger logger = null)
         {
             OutputPath = DefaultOutputPath;
@@ -61,7 +56,7 @@ public void InstrumentSampleProject()
             Instrumenter instrumenter = new Instrumenter(options, _logger);
             instrumenter.BackupFolder = Path.Combine(OutputPath, "backup");
             Directory.CreateDirectory(instrumenter.BackupFolder);
-            Map = instrumenter.Instrument();
+            RecordingController = instrumenter.Instrument();
             InstrumentedAssemblyPath = assemblyFileName;
         }
 
@@ -77,19 +72,17 @@ public void RunSomeCode()
         {
             if (InstrumentedAssemblyPath == null)
                 throw new InvalidOperationException("Sample assembly is not instrumented.");
-            var client = RecordingController.ForEndPoint("localhost", PortNumber, Map, _logger);
             Assembly.LoadFrom(Path.Combine(OutputPath, "SG.CodeCoverage.Recorder.dll"));
             var assembly = Assembly.LoadFrom(InstrumentedAssemblyPath);
             var calc = assembly.DefinedTypes.Where(x => x.Name == nameof(PrimeCalculator)).FirstOrDefault();
             var res = calc.GetMethod("IsPrime").Invoke(calc.DeclaredConstructors.First().Invoke(null), new object[] { 7 });
         }
 
-        public List<string> GetVisitedFiles()
+        public CoverageResult GetCoverageResult()
         {
-            if (InstrumentedAssemblyPath == null)
+            if (InstrumentedAssemblyPath == null || RecordingController == null)
                 throw new InvalidOperationException("Sample assembly is not instrumented.");
-            var client = RecordingController.ForEndPoint("localhost", PortNumber, Map, _logger);
-            return client.CollectResultAndReset().GetVisitedSources().ToList(); ;
+            return RecordingController.CollectResultAndReset();
         }
     }
 }
diff --git a/SG.CodeCoverage/Collection/DynamicPortRecordingController.cs b/SG.CodeCoverage/Collection/DynamicPortRecordingController.cs
@@ -9,7 +9,7 @@
 
 namespace SG.CodeCoverage.Collection
 {
-    internal class MultiRecordingController : IRecordingController
+    internal class DynamicPortRecordingController : IRecordingController
     {
         private readonly string _recorderRuntimeConfigFilePath;
         private readonly InstrumentationMap _map;
@@ -18,13 +18,15 @@ internal class MultiRecordingController : IRecordingController
         private RuntimeConfig _currentRuntimeConfig;
         private const string _host = "localhost";
 
-        public MultiRecordingController(string recorderRuntimeConfigFilePath, InstrumentationMap map, ILogger logger = null)
+        public DynamicPortRecordingController(string recorderRuntimeConfigFilePath, InstrumentationMap map, ILogger logger = null)
         {
             _recorderRuntimeConfigFilePath = recorderRuntimeConfigFilePath;
             _map = map;
             _logger = logger ?? new ConsoleLogger();
         }
 
+        public InstrumentationMap InstrumentationMap => _map;
+
         public void ResetHits()
         {
             if (!LoadRuntimeConfig())
diff --git a/SG.CodeCoverage/Collection/FixedPortRecordingController.cs b/SG.CodeCoverage/Collection/FixedPortRecordingController.cs
@@ -4,21 +4,23 @@
 
 namespace SG.CodeCoverage.Collection
 {
-    internal class SingleRecordingController : IRecordingController
+    internal class FixedPortRecordingController : IRecordingController
     {
         private readonly string _host;
         private readonly int _port;
         private readonly InstrumentationMap _map;
         private readonly ILogger _logger;
 
-        public SingleRecordingController(string host, int port, InstrumentationMap map, ILogger logger = null)
+        public FixedPortRecordingController(string host, int port, InstrumentationMap map, ILogger logger = null)
         {
             _host = host;
             _port = port;
             _map = map;
             _logger = logger ?? new ConsoleLogger();
         }
 
+        public InstrumentationMap InstrumentationMap => _map;
+
         public CoverageResult CollectResultAndReset()
         {
             _logger.LogInformation($"Collecting coverage result for {_host}:{_port}");
diff --git a/SG.CodeCoverage/Collection/IRecordingController.cs b/SG.CodeCoverage/Collection/IRecordingController.cs
@@ -1,9 +1,11 @@
 ﻿using SG.CodeCoverage.Coverage;
+using SG.CodeCoverage.Metadata;
 
 namespace SG.CodeCoverage.Collection
 {
     public interface IRecordingController
     {
+        InstrumentationMap InstrumentationMap { get; }
         void ResetHits();
         CoverageResult CollectResultAndReset();
     }
diff --git a/SG.CodeCoverage/Collection/RecordingController.cs b/SG.CodeCoverage/Collection/RecordingController.cs
@@ -7,12 +7,12 @@ public static class RecordingController
     {
         public static IRecordingController ForRuntimeConfigFile(string runtimeConfigFilePath, InstrumentationMap map, ILogger logger)
         {
-            return new MultiRecordingController(runtimeConfigFilePath, map, logger);
+            return new DynamicPortRecordingController(runtimeConfigFilePath, map, logger);
         }
 
         public static IRecordingController ForEndPoint(string host, int port, InstrumentationMap map, ILogger logger)
         {
-            return new SingleRecordingController(host, port, map, logger);
+            return new FixedPortRecordingController(host, port, map, logger);
         }
     }
 }
diff --git a/SG.CodeCoverage/Instrumentation/Instrumenter.cs b/SG.CodeCoverage/Instrumentation/Instrumenter.cs
@@ -6,6 +6,7 @@
 using System.IO;
 using Newtonsoft.Json;
 using Mono.Cecil.Cil;
+using SG.CodeCoverage.Collection;
 using SG.CodeCoverage.Metadata;
 
 namespace SG.CodeCoverage.Instrumentation
@@ -53,7 +54,7 @@ public Instrumenter(
         {
         }
 
-        public InstrumentationMap Instrument()
+        public Collection.IRecordingController Instrument()
         {
             UniqueId = Guid.NewGuid();
 
@@ -65,7 +66,24 @@ public InstrumentationMap Instrument()
             if (!string.IsNullOrEmpty(OutputMapFilePath))
                 SaveMapFile(map, OutputMapFilePath);
 
-            return map;
+            return CreateRecordingController(map);
+        }
+
+        private IRecordingController CreateRecordingController(InstrumentationMap map)
+        {
+            if (Options.ControllerPortNumber > 0)
+            {
+                return new FixedPortRecordingController(
+                    "localhost", Options.ControllerPortNumber, map, _logger);
+            }
+            else
+            {
+                var dir = Options.RuntimeConfigOutputPath;
+                if (string.IsNullOrEmpty(dir))
+                    dir = Options.RecorderAssemblyCopyPath;
+                var fullPath = Path.Combine(dir, Options.RuntimeConfigOutputPath);
+                return new DynamicPortRecordingController(fullPath , map, _logger);
+            }
         }
 
         private InstrumentationMap InstrumentInternal()
diff --git a/SG.CodeCoverage/SG.CodeCoverage.csproj b/SG.CodeCoverage/SG.CodeCoverage.csproj
@@ -44,10 +44,10 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Collection\IRecordingController.cs" />
-    <Compile Include="Collection\MultiRecordingController.cs" />
+    <Compile Include="Collection\DynamicPortRecordingController.cs" />
     <Compile Include="Collection\RecordingControllerClient.cs" />
     <Compile Include="Collection\RecordingController.cs" />
-    <Compile Include="Collection\SingleRecordingController.cs" />
+    <Compile Include="Collection\FixedPortRecordingController.cs" />
     <Compile Include="Common\ConsoleLogger.cs" />
     <Compile Include="Common\ILogger.cs" />
     <Compile Include="Common\VersionInfo.cs" />

Original file line number	Diff line number	Diff line change
`@@ -14,19 +14,14 @@ namespace SG.CodeCoverage.Tests`
`14`	`14`	`{`
`15`	`15`	`public class InstrumenterTester`
`16`	`16`	`{`
`17`		`- public const int PortNumber = 61238;`
`18`		`- public static string DefaultOutputPath { get; }`
	`17`	`+ public int PortNumber { get; set; } = 61238;`
	`18`	`+ public static string DefaultOutputPath { get; } = Path.Combine(Path.GetTempPath(), "SG.CodeCoverage");`
`19`	`19`	`public string OutputPath { get; }`
`20`	`20`	`public string MapFilePath { get; }`
`21`		`- public InstrumentationMap Map { get; private set; }`
	`21`	`+ public IRecordingController RecordingController { get; private set; }`
`22`	`22`	`public string InstrumentedAssemblyPath { get; private set; }`
`23`	`23`	`private readonly ILogger _logger;`
`24`	`24`
`25`		`- static InstrumenterTester()`
`26`		`- {`
`27`		`- DefaultOutputPath = Path.Combine(Path.GetTempPath(), "SG.CodeCoverage");`
`28`		`- }`
`29`		`-`
`30`	`25`	`public InstrumenterTester(ILogger logger = null)`
`31`	`26`	`{`
`32`	`27`	`OutputPath = DefaultOutputPath;`
`@@ -61,7 +56,7 @@ public void InstrumentSampleProject()`
`61`	`56`	`Instrumenter instrumenter = new Instrumenter(options, _logger);`
`62`	`57`	`instrumenter.BackupFolder = Path.Combine(OutputPath, "backup");`
`63`	`58`	`Directory.CreateDirectory(instrumenter.BackupFolder);`
`64`		`- Map = instrumenter.Instrument();`
	`59`	`+ RecordingController = instrumenter.Instrument();`
`65`	`60`	`InstrumentedAssemblyPath = assemblyFileName;`
`66`	`61`	`}`
`67`	`62`
`@@ -77,19 +72,17 @@ public void RunSomeCode()`
`77`	`72`	`{`
`78`	`73`	`if (InstrumentedAssemblyPath == null)`
`79`	`74`	`throw new InvalidOperationException("Sample assembly is not instrumented.");`
`80`		`- var client = RecordingController.ForEndPoint("localhost", PortNumber, Map, _logger);`
`81`	`75`	`Assembly.LoadFrom(Path.Combine(OutputPath, "SG.CodeCoverage.Recorder.dll"));`
`82`	`76`	`var assembly = Assembly.LoadFrom(InstrumentedAssemblyPath);`
`83`	`77`	`var calc = assembly.DefinedTypes.Where(x => x.Name == nameof(PrimeCalculator)).FirstOrDefault();`
`84`	`78`	`var res = calc.GetMethod("IsPrime").Invoke(calc.DeclaredConstructors.First().Invoke(null), new object[] { 7 });`
`85`	`79`	`}`
`86`	`80`
`87`		`- public List<string> GetVisitedFiles()`
	`81`	`+ public CoverageResult GetCoverageResult()`
`88`	`82`	`{`
`89`		`- if (InstrumentedAssemblyPath == null)`
	`83`	`+ if (InstrumentedAssemblyPath == null \|\| RecordingController == null)`
`90`	`84`	`throw new InvalidOperationException("Sample assembly is not instrumented.");`
`91`		`- var client = RecordingController.ForEndPoint("localhost", PortNumber, Map, _logger);`
`92`		`- return client.CollectResultAndReset().GetVisitedSources().ToList(); ;`
	`85`	`+ return RecordingController.CollectResultAndReset();`
`93`	`86`	`}`
`94`	`87`	`}`
`95`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`
`10`	`10`	`namespace SG.CodeCoverage.Collection`
`11`	`11`	`{`
`12`		`- internal class MultiRecordingController : IRecordingController`
	`12`	`+ internal class DynamicPortRecordingController : IRecordingController`
`13`	`13`	`{`
`14`	`14`	`private readonly string _recorderRuntimeConfigFilePath;`
`15`	`15`	`private readonly InstrumentationMap _map;`
`@@ -18,13 +18,15 @@ internal class MultiRecordingController : IRecordingController`
`18`	`18`	`private RuntimeConfig _currentRuntimeConfig;`
`19`	`19`	`private const string _host = "localhost";`
`20`	`20`
`21`		`- public MultiRecordingController(string recorderRuntimeConfigFilePath, InstrumentationMap map, ILogger logger = null)`
	`21`	`+ public DynamicPortRecordingController(string recorderRuntimeConfigFilePath, InstrumentationMap map, ILogger logger = null)`
`22`	`22`	`{`
`23`	`23`	`_recorderRuntimeConfigFilePath = recorderRuntimeConfigFilePath;`
`24`	`24`	`_map = map;`
`25`	`25`	`_logger = logger ?? new ConsoleLogger();`
`26`	`26`	`}`
`27`	`27`
	`28`	`+ public InstrumentationMap InstrumentationMap => _map;`
	`29`	`+`
`28`	`30`	`public void ResetHits()`
`29`	`31`	`{`
`30`	`32`	`if (!LoadRuntimeConfig())`
Original file line number	Diff line number	Diff line change
`@@ -4,21 +4,23 @@`
`4`	`4`
`5`	`5`	`namespace SG.CodeCoverage.Collection`
`6`	`6`	`{`
`7`		`- internal class SingleRecordingController : IRecordingController`
	`7`	`+ internal class FixedPortRecordingController : IRecordingController`
`8`	`8`	`{`
`9`	`9`	`private readonly string _host;`
`10`	`10`	`private readonly int _port;`
`11`	`11`	`private readonly InstrumentationMap _map;`
`12`	`12`	`private readonly ILogger _logger;`
`13`	`13`
`14`		`- public SingleRecordingController(string host, int port, InstrumentationMap map, ILogger logger = null)`
	`14`	`+ public FixedPortRecordingController(string host, int port, InstrumentationMap map, ILogger logger = null)`
`15`	`15`	`{`
`16`	`16`	`_host = host;`
`17`	`17`	`_port = port;`
`18`	`18`	`_map = map;`
`19`	`19`	`_logger = logger ?? new ConsoleLogger();`
`20`	`20`	`}`
`21`	`21`
	`22`	`+ public InstrumentationMap InstrumentationMap => _map;`
	`23`	`+`
`22`	`24`	`public CoverageResult CollectResultAndReset()`
`23`	`25`	`{`
`24`	`26`	`_logger.LogInformation($"Collecting coverage result for {_host}:{_port}");`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,11 @@`
`1`	`1`	`using SG.CodeCoverage.Coverage;`
	`2`	`+using SG.CodeCoverage.Metadata;`
`2`	`3`
`3`	`4`	`namespace SG.CodeCoverage.Collection`
`4`	`5`	`{`
`5`	`6`	`public interface IRecordingController`
`6`	`7`	`{`
	`8`	`+ InstrumentationMap InstrumentationMap { get; }`
`7`	`9`	`void ResetHits();`
`8`	`10`	`CoverageResult CollectResultAndReset();`
`9`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,12 +7,12 @@ public static class RecordingController`
`7`	`7`	`{`
`8`	`8`	`public static IRecordingController ForRuntimeConfigFile(string runtimeConfigFilePath, InstrumentationMap map, ILogger logger)`
`9`	`9`	`{`
`10`		`- return new MultiRecordingController(runtimeConfigFilePath, map, logger);`
	`10`	`+ return new DynamicPortRecordingController(runtimeConfigFilePath, map, logger);`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`public static IRecordingController ForEndPoint(string host, int port, InstrumentationMap map, ILogger logger)`
`14`	`14`	`{`
`15`		`- return new SingleRecordingController(host, port, map, logger);`
	`15`	`+ return new FixedPortRecordingController(host, port, map, logger);`
`16`	`16`	`}`
`17`	`17`	`}`
`18`	`18`	`}`