Initial refactoring.

Author: Matasx

xmr-stak-bootstrap/DictionaryExtensions.cs renamed to xmr-stak-bootstrap/Common/DictionaryExtensions.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace xmr_stak_bootstrap
+namespace XmrStakBootstrap.Common
 {
     public static class DictionaryExtensions
     {

xmr-stak-bootstrap/ConfigurationParser.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Threading;
 
-namespace xmr_stak_bootstrap
+namespace XmrStakBootstrap.Core
 {
     public class Finalizer : IFinalizer
     {

xmr-stak-bootstrap/Finalizer.cs renamed to xmr-stak-bootstrap/Core/Finalizer.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace xmr_stak_bootstrap
+namespace XmrStakBootstrap.Core
 {
     public interface IFinalizer
     {

xmr-stak-bootstrap/IFinalizer.cs renamed to xmr-stak-bootstrap/Core/IFinalizer.cs

@@ -0,0 +1,19 @@
+using Unity.Attributes;
+using XmrStakBootstrap.RunConfiguration.Model;
+
+namespace XmrStakBootstrap.Core.Runner.Generator
+{
+    public class ConfigurationGeneratorRunner : IRunner
+    {
+        [Dependency]
+        public ISampleConfigurationGenerator SampleConfigurationGenerator { get; set; }
+
+        [Dependency]
+        public RunConfigurationModel ConfigurationModel { get; set; }
+
+        public void Run()
+        {
+            SampleConfigurationGenerator.Generate(ConfigurationModel.MasterConfiguration);
+        }
+    }
+}

xmr-stak-bootstrap/Core/Runner/Generator/ConfigurationGeneratorRunner.cs

@@ -1,4 +1,4 @@
-namespace xmr_stak_bootstrap
+namespace XmrStakBootstrap.Core.Runner.Generator
 {
     public interface ISampleConfigurationGenerator
     {

xmr-stak-bootstrap/ISampleConfigurationGenerator.cs renamed to xmr-stak-bootstrap/Core/Runner/Generator/ISampleConfigurationGenerator.cs

@@ -1,16 +1,16 @@
 using System;
 using System.IO;
 using Newtonsoft.Json;
-using xmr_stak_bootstrap.Model;
-using xmr_stak_bootstrap.Properties;
+using XmrStakBootstrap.MasterConfiguration.Model;
+using XmrStakBootstrap.Properties;
 
-namespace xmr_stak_bootstrap
+namespace XmrStakBootstrap.Core.Runner.Generator
 {
     public class SampleConfigurationGenerator : ISampleConfigurationGenerator
     {
         public void Generate(string path)
         {
-            var configuration = SampleConfigurationData.MasterConfiguration;
+            var configuration = SampleConfigurationData.MasterConfigurationModel;
             var contents = JsonConvert.SerializeObject(configuration, Formatting.Indented);
             WriteAllText(path, contents);
             WriteAllText(configuration.ConfigTemplate, Resources.config_source);

xmr-stak-bootstrap/SampleConfigurationGenerator.cs renamed to xmr-stak-bootstrap/Core/Runner/Generator/SampleConfigurationGenerator.cs

@@ -0,0 +1,7 @@
+namespace XmrStakBootstrap.Core.Runner
+{
+    public interface IRunner
+    {
+        void Run();
+    }
+}

xmr-stak-bootstrap/Core/Runner/IRunner.cs

@@ -0,0 +1,7 @@
+namespace XmrStakBootstrap.Core.Runner
+{
+    public interface IRunnerContext
+    {
+        void Execute();
+    }
+}

xmr-stak-bootstrap/Core/Runner/IRunnerContext.cs

@@ -5,80 +5,74 @@
 using System.Linq;
 using Newtonsoft.Json;
 using Unity.Attributes;
-using xmr_stak_bootstrap.Model;
+using XmrStakBootstrap.Common;
+using XmrStakBootstrap.MasterConfiguration.Model;
+using XmrStakBootstrap.RunConfiguration.Model;
 
-namespace xmr_stak_bootstrap
+namespace XmrStakBootstrap.Core.Runner.Miner
 {
-    public class Runner : IRunner
+    public class MinerRunner : IRunner
     {
-        //TODO: can be refactored further to classes
-
         [Dependency]
         public IFinalizer Finalizer { get; set; }
 
         [Dependency]
-        public Lazy<ISampleConfigurationGenerator> SampleConfigurationGenerator { get; set; }
+        public RunConfigurationModel RunConfigurationModel { get; set; }
+
+        [Dependency]
+        public MasterConfigurationModel MasterConfigurationModel { get; set; }
 
-        public void Run(RunConfiguration args)
+        public void Run()
         {
-            if (args.GenerateConfigurationOnly)
+            if (MasterConfigurationModel == null)
             {
-                SampleConfigurationGenerator.Value.Generate(args.MasterConfiguration);
+                Console.WriteLine(@"Master configuration file '{0}' was not loaded. Try running this program with argument --help.", RunConfigurationModel.MasterConfiguration);
+                return;
             }
-            else
-            {
-                if (!File.Exists(args.MasterConfiguration))
-                {
-                    Console.WriteLine(@"Configuration file '{0}' does not exist. Try running this program with argument --help.", args.MasterConfiguration);
-                    return;
-                }
 
-                DoRun(args);
-            }
+            DoRun();
         }
 
-        private void DoRun(RunConfiguration args)
+        private void DoRun()
         {
-            var contents = File.ReadAllText(args.MasterConfiguration);
-            var configuration = JsonConvert.DeserializeObject<MasterConfiguration>(contents);
-
-            var activeSolution = GetActiveSolution(args, configuration);
+            var activeSolution = GetActiveSolution();
             KillMiners();
 
-            var solution = configuration.SolutionConfiguration.SolutionProfiles.GetValue(activeSolution);
+            var solution = MasterConfigurationModel.SolutionConfiguration.SolutionProfiles.GetValue(activeSolution);
             foreach (var instances in solution)
             {
-                var outputPools = GetOutputPools(configuration, instances);
+                var outputPools = GetOutputPools(instances);
 
                 if (outputPools.Count == 0)
                 {
                     Console.WriteLine(@"Solution does not contain any pool bindings.");
                     continue;
                 }
 
-                var configArgument = GetConfigurationArgument(configuration, outputPools);
+                var configArgument = GetConfigurationArgument(outputPools);
 
                 foreach (var instance in instances.Value)
                 {
-                    var entry = configuration.InstanceConfiguration.InstanceProfiles.GetValue(instance);
+                    var entry = MasterConfigurationModel.InstanceConfiguration.InstanceProfiles.GetValue(instance);
 
-                    var cpuArgument = GetCpuArgument(configuration, entry);
-                    var amdArgument = GetAmdArgument(configuration, entry);
-                    var nvidiaArgument = GetNvidiaArgument(configuration, entry);
+                    var cpuArgument = GetCpuArgument(entry);
+                    var amdArgument = GetAmdArgument(entry);
+                    var nvidiaArgument = GetNvidiaArgument(entry);
 
                     RunMiner($"{configArgument} {cpuArgument} {amdArgument} {nvidiaArgument}");
                 }
             }
         }
 
-        private static string GetActiveSolution(RunConfiguration args, MasterConfiguration configuration)
+        private string GetActiveSolution()
         {
-            var activeSolution = args.ActiveSolutionConfiguration;
+            //TODO: rewrite once configuration is changed
+            var activeSolution = RunConfigurationModel.ActiveSolutionConfiguration;
 
             while (string.IsNullOrEmpty(activeSolution))
             {
                 Console.WriteLine(@"Available solutions: ");
-                var keys = configuration.SolutionConfiguration.SolutionProfiles.Keys.OrderBy(x => x).ToList();
+                var keys = MasterConfigurationModel.SolutionConfiguration.SolutionProfiles.Keys.ToList();
                 var i = 0;
                 foreach (var key in keys)
                 {
@@ -96,13 +90,13 @@ private static string GetActiveSolution(RunConfiguration args, MasterConfigurati
             return activeSolution;
         }
 
-        private static List<PrioritizedPoolEntry> GetOutputPools(MasterConfiguration configuration, KeyValuePair<string, IList<string>> instances)
+        private List<PrioritizedPoolEntry> GetOutputPools(KeyValuePair<string, IList<string>> instances)
         {
-            return configuration
+            return MasterConfigurationModel
                 .PoolConfiguration
                 .PoolSets.GetValue(instances.Key)
                 .Reverse()
-                .Select(x => configuration.PoolConfiguration.Pools.GetValue(x))
+                .Select(x => MasterConfigurationModel.PoolConfiguration.Pools.GetValue(x))
                 .Select((x, i) => new PrioritizedPoolEntry
                 {
                     PoolWeight = i + 1,
@@ -116,7 +110,7 @@ private static List<PrioritizedPoolEntry> GetOutputPools(MasterConfiguration con
                 .ToList();
         }
 
-        private void RunMiner(string arguments)
+        private static void RunMiner(string arguments)
         {
             var startInfo = new ProcessStartInfo(Path.GetFullPath("xmr-stak.exe"), arguments)
             {
@@ -128,51 +122,51 @@ private void RunMiner(string arguments)
             Process.Start(startInfo);
         }
 
-        private string GetConfigurationArgument(MasterConfiguration configuration, List<PrioritizedPoolEntry> pools)
+        private string GetConfigurationArgument(IReadOnlyCollection<PrioritizedPoolEntry> pools)
         {
-            var configPath = CreateTemporaryConfiguration(configuration.ConfigTemplate, "config", "%POOLS%", pools);
+            var configPath = CreateTemporaryConfiguration(MasterConfigurationModel.ConfigTemplate, "config", "%POOLS%", pools);
             ScheduleFileDelete(configPath);
 
             return $"--config \"{configPath}\"";
         }
 
-        private string GetCpuArgument(MasterConfiguration configuration, InstanceEntry entry)
+        private string GetCpuArgument(InstanceEntry entry)
         {
             if (string.IsNullOrEmpty(entry.CpuProfile))
             {
                 return "--noCPU";
             }
 
-            var cpuProfile = configuration.CpuConfiguration.Profiles.GetValue(entry.CpuProfile);
-            var path = CreateTemporaryConfiguration(configuration.CpuTemplate, "cpu", "%THREADS%", cpuProfile);
+            var cpuProfile = MasterConfigurationModel.CpuConfiguration.Profiles.GetValue(entry.CpuProfile);
+            var path = CreateTemporaryConfiguration(MasterConfigurationModel.CpuTemplate, "cpu", "%THREADS%", cpuProfile);
             ScheduleFileDelete(path);
 
             return $"--cpu \"{path}\"";
         }
 
-        private string GetAmdArgument(MasterConfiguration configuration, InstanceEntry entry)
+        private string GetAmdArgument(InstanceEntry entry)
         {
             if (entry.AmdProfiles == null || entry.AmdProfiles.Count == 0)
             {
                 return "--noAMD";
             }
 
-            var amdProfile = entry.AmdProfiles.SelectMany(x => configuration.AmdConfiguration.Profiles.GetValue(x)).ToList();
-            var path = CreateTemporaryConfiguration(configuration.AmdTemplate, "amd", "%THREADS%", amdProfile);
+            var amdProfile = entry.AmdProfiles.SelectMany(x => MasterConfigurationModel.AmdConfiguration.Profiles.GetValue(x)).ToList();
+            var path = CreateTemporaryConfiguration(MasterConfigurationModel.AmdTemplate, "amd", "%THREADS%", amdProfile);
             ScheduleFileDelete(path);
 
             return $"--amd \"{path}\"";
         }
 
-        private string GetNvidiaArgument(MasterConfiguration configuration, InstanceEntry entry)
+        private string GetNvidiaArgument(InstanceEntry entry)
         {
             if (entry.NvidiaProfiles == null || entry.NvidiaProfiles.Count == 0)
             {
                 return "--noNVIDIA";
             }
 
-            var nvidiaProfile = entry.NvidiaProfiles.SelectMany(x => configuration.NvidiaConfiguration.Profiles.GetValue(x)).ToList();
-            var path = CreateTemporaryConfiguration(configuration.NvidiaTemplate, "nvidia", "%THREADS%", nvidiaProfile);
+            var nvidiaProfile = entry.NvidiaProfiles.SelectMany(x => MasterConfigurationModel.NvidiaConfiguration.Profiles.GetValue(x)).ToList();
+            var path = CreateTemporaryConfiguration(MasterConfigurationModel.NvidiaTemplate, "nvidia", "%THREADS%", nvidiaProfile);
             ScheduleFileDelete(path);
 
             return $"--nvidia \"{path}\"";