Changing shell settings loader to prep for multi-tenancy work

Adding data prefix property
Moving to a different yaml library
Renaming IShellSettingsLoader and ShellSettingsLoader to ITenantManager and DefaultTenantManager
Avoiding use of MapPath in the appdatafolder abstraction

--HG--
branch : dev

src/Orchard.Tests/Environment/Configuration/AppDataFolderTests.cs

@@ -77,5 +77,19 @@ namespace Orchard.Tests.Environment.Configuration {
             _appDataFolder.CreateFile("alpha\\omega\\foo\\bar.txt", "quux");
             Assert.That(Directory.Exists(Path.Combine(_tempFolder, "alpha\\omega\\foo")), Is.True);
         }
+
+
+        [Test]
+        public void FilesCanBeReadBack() {            
+            _appDataFolder.CreateFile("alpha\\gamma\\foo\\bar.txt", @"
+this is
+a
+test");
+            var text = _appDataFolder.ReadFile("alpha\\gamma\\foo\\bar.txt");
+            Assert.That(text, Is.EqualTo(@"
+this is
+a
+test"));
+        }
     }
 }

src/Orchard.Tests/Environment/Configuration/DefaultTenantManagerTests.cs

@@ -0,0 +1,76 @@
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+using Orchard.Environment.Configuration;
+
+namespace Orchard.Tests.Environment.Configuration {
+    [TestFixture]
+    public class ShellSettingsLoaderTests {
+        private string _tempFolder;
+        private AppDataFolder _appData;
+
+        [SetUp]
+        public void Init() {
+            _appData = new AppDataFolder();
+            _tempFolder = Path.GetTempFileName();
+            File.Delete(_tempFolder);
+            _appData.SetBasePath(_tempFolder);
+        }
+        [TearDown]
+        public void Term() {
+            Directory.Delete(_tempFolder, true);
+        }
+
+        [Test]
+        public void SingleSettingsFileShouldComeBackAsExpected() {
+            
+            _appData.CreateFile("Sites\\Default\\Settings.txt", "Name: Default\r\nDataProvider: SQLite\r\nDataConnectionString: something else");
+
+            IShellSettingsLoader loader = new ShellSettingsLoader(_appData);
+            var settings = loader.LoadSettings().Single();
+            Assert.That(settings, Is.Not.Null);
+            Assert.That(settings.Name, Is.EqualTo("Default"));
+            Assert.That(settings.DataProvider, Is.EqualTo("SQLite"));
+            Assert.That(settings.DataConnectionString, Is.EqualTo("something else"));
+        }
+
+
+        [Test]
+        public void MultipleFilesCanBeDetected() {
+
+            _appData.CreateFile("Sites\\Default\\Settings.txt", "Name: Default\r\nDataProvider: SQLite\r\nDataConnectionString: something else");
+            _appData.CreateFile("Sites\\Another\\Settings.txt", "Name: Another\r\nDataProvider: SQLite2\r\nDataConnectionString: something else2");
+
+            IShellSettingsLoader loader = new ShellSettingsLoader(_appData);
+            var settings = loader.LoadSettings();
+            Assert.That(settings.Count(), Is.EqualTo(2));
+
+            var def = settings.Single(x => x.Name == "Default");
+            Assert.That(def.Name, Is.EqualTo("Default"));
+            Assert.That(def.DataProvider, Is.EqualTo("SQLite"));
+            Assert.That(def.DataConnectionString, Is.EqualTo("something else"));
+
+            var alt = settings.Single(x => x.Name == "Another");
+            Assert.That(alt.Name, Is.EqualTo("Another"));
+            Assert.That(alt.DataProvider, Is.EqualTo("SQLite2"));
+            Assert.That(alt.DataConnectionString, Is.EqualTo("something else2"));
+        }
+
+        [Test]
+        public void NewSettingsCanBeStored() {
+            _appData.CreateFile("Sites\\Default\\Settings.txt", "Name: Default\r\nDataProvider: SQLite\r\nDataConnectionString: something else");
+            
+            IShellSettingsLoader loader = new ShellSettingsLoader(_appData);
+            var foo = new ShellSettings {Name = "Foo", DataProvider = "Bar", DataConnectionString = "Quux"};
+
+            Assert.That(loader.LoadSettings().Count(), Is.EqualTo(1));
+            loader.SaveSettings(foo);
+            Assert.That(loader.LoadSettings().Count(), Is.EqualTo(2));
+
+            var text = File.ReadAllText(_appData.MapPath("Sites\\Foo\\Settings.txt"));
+            Assert.That(text, Is.StringContaining("Foo"));
+            Assert.That(text, Is.StringContaining("Bar"));
+            Assert.That(text, Is.StringContaining("Quux"));
+        }
+    }
+}

src/Orchard.Tests/Orchard.Tests.csproj

@@ -153,6 +153,7 @@
     <Compile Include="Data\StubLocator.cs" />
     <Compile Include="Environment\AutofacUtil\DynamicProxy2\DynamicProxyTests.cs" />
     <Compile Include="Environment\Configuration\AppDataFolderTests.cs" />
+    <Compile Include="Environment\Configuration\ShellSettingsLoaderTests.cs" />
     <Compile Include="Environment\DefaultCompositionStrategyTests.cs" />
     <Compile Include="Environment\DefaultOrchardHostTests.cs" />
     <Compile Include="Environment\DefaultOrchardShellTests.cs" />

src/Orchard/Environment/Configuration/AppDataFolder.cs

@@ -15,6 +15,7 @@ namespace Orchard.Environment.Configuration {
         IEnumerable<string> ListDirectories(string path);
 
         void CreateFile(string path, string content);
+        string ReadFile(string path);
         void DeleteFile(string path);
 
         string CreateDirectory(string path);
@@ -26,7 +27,6 @@ namespace Orchard.Environment.Configuration {
         /// </summary>
         void SetBasePath(string basePath);
         string MapPath(string path);
-
     }
 
     public class AppDataFolder : IAppDataFolder {
@@ -44,6 +44,10 @@ namespace Orchard.Environment.Configuration {
             File.WriteAllText(filePath, content);
         }
 
+        public string ReadFile(string path) {
+            return File.ReadAllText(Path.Combine(_basePath, path));
+        }
+
         public void DeleteFile(string path) {
             File.Delete(Path.Combine(_basePath, path));
         }

src/Orchard/Environment/Configuration/DefaultTenantManager.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Yaml.Serialization;
+using Orchard.Localization;
+
+namespace Orchard.Environment.Configuration {
+    public class DefaultTenantManager : ITenantManager {
+        private readonly IAppDataFolder _appDataFolder;
+        Localizer T { get; set; }
+
+        public DefaultTenantManager(IAppDataFolder appDataFolder) {
+            _appDataFolder = appDataFolder;
+            T = NullLocalizer.Instance;
+        }
+
+        IEnumerable<IShellSettings> ITenantManager.LoadSettings() {
+            return LoadSettings().ToArray();
+        }
+
+        void ITenantManager.SaveSettings(IShellSettings settings) {
+            if (settings == null)
+                throw new ArgumentException(T("There are no settings to save.").ToString());
+            if (string.IsNullOrEmpty(settings.Name))
+                throw new ArgumentException(T("Settings \"Name\" is not set.").ToString());
+
+            var filePath = Path.Combine(Path.Combine("Sites", settings.Name), "Settings.txt");
+            _appDataFolder.CreateFile(filePath, ComposeSettings(settings));
+        }
+
+        IEnumerable<IShellSettings> LoadSettings() {
+            var filePaths = _appDataFolder
+                .ListDirectories("Sites")
+                .SelectMany(path => _appDataFolder.ListFiles(path))
+                .Where(path => string.Equals(Path.GetFileName(path), "Settings.txt", StringComparison.OrdinalIgnoreCase));
+
+            foreach (var filePath in filePaths) {
+                yield return ParseSettings(_appDataFolder.ReadFile(filePath));
+            }
+        }
+
+        class Content {
+            public string Name { get; set; }
+            public string DataProvider { get; set; }
+            public string DataConnectionString { get; set; }
+        }
+
+        static IShellSettings ParseSettings(string text) {
+            var ser = new YamlSerializer();
+            var content = ser.Deserialize(text, typeof(Content)).Cast<Content>().Single();
+            return new ShellSettings {
+                Name = content.Name,
+                DataProvider = content.DataProvider,
+                DataConnectionString = content.DataConnectionString,
+                DataPrefix = content.DataPrefix,
+            };
+        }
+
+        static string ComposeSettings(IShellSettings shellSettings) {
+            if (shellSettings == null)
+                return "";
+
+            var ser = new YamlSerializer();
+            return ser.Serialize(new Content {
+                Name = shellSettings.Name,
+                DataProvider = shellSettings.DataProvider,
+                DataConnectionString = shellSettings.DataConnectionString
+            });
+        }
+    }
+}

src/Orchard/Environment/Configuration/ITenantManager.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+
+namespace Orchard.Environment.Configuration {
+    public interface ITenantManager {
+        IEnumerable<IShellSettings> LoadSettings();
+        void SaveSettings(IShellSettings settings);
+    }
+}

src/Orchard/Environment/Configuration/ShellSettings.cs

@@ -1,13 +1,15 @@
 namespace Orchard.Environment.Configuration {
     public interface IShellSettings {
-        string Name { get; set; }
-        string DataProvider { get; set; }
-        string DataConnectionString { get; set; }
+        string Name { get; }
+        string DataProvider { get; }
+        string DataConnectionString { get; }
+        string DataPrefix { get; }
     }
 
     public class ShellSettings : IShellSettings {
         public string Name { get; set; }
         public string DataProvider { get; set; }
         public string DataConnectionString { get; set; }
+        public string DataPrefix { get; set; }
     }
 }

src/Orchard/Environment/Configuration/ShellSettingsLoader.cs

@@ -1,93 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Web.Hosting;
-using Orchard.Localization;
-using Yaml.Grammar;
-
-namespace Orchard.Environment.Configuration {
-    public interface IShellSettingsLoader {
-        IEnumerable<IShellSettings> LoadSettings();
-        void SaveSettings(IShellSettings settings);
-    }
-
-    public class ShellSettingsLoader : IShellSettingsLoader {
-        private readonly IAppDataFolder _appDataFolder;
-        Localizer T { get; set; }
-
-        public ShellSettingsLoader(IAppDataFolder appDataFolder) {
-            _appDataFolder = appDataFolder;
-            T = NullLocalizer.Instance;
-        }
-
-        IEnumerable<IShellSettings> IShellSettingsLoader.LoadSettings() {
-            return LoadSettings().ToArray();
-        }
-
-        public void SaveSettings(IShellSettings settings) {
-            if (settings == null)
-                throw new ArgumentException(T("There are no settings to save.").ToString());
-            if (string.IsNullOrEmpty(settings.Name))
-                throw new ArgumentException(T("Settings \"Name\" is not set.").ToString());
-
-            var settingsFile = Path.Combine(Path.Combine("Sites", settings.Name), "Settings.txt");
-            _appDataFolder.CreateFile(settingsFile, ComposeSettings(settings));
-        }
-
-        IEnumerable<IShellSettings> LoadSettings() {
-            foreach (var yamlDocument in LoadFiles()) {
-                yield return ParseSettings(yamlDocument);
-            }
-        }
-
-        IEnumerable<YamlDocument> LoadFiles() {
-            var sitePaths = _appDataFolder
-                .ListDirectories("Sites")
-                .SelectMany(path => _appDataFolder.ListFiles(path))
-                .Where(path => string.Equals(Path.GetFileName(path), "Settings.txt", StringComparison.OrdinalIgnoreCase));
-
-            foreach (var sitePath in sitePaths) {
-                var yamlStream = YamlParser.Load(_appDataFolder.MapPath(sitePath));
-                yield return yamlStream.Documents.Single();
-            }
-        }
-
-        static IShellSettings ParseSettings(YamlDocument document) {
-            var mapping = (Mapping)document.Root;
-            var fields = mapping.Entities
-                .Where(x => x.Key is Scalar)
-                .ToDictionary(x => ((Scalar)x.Key).Text, x => x.Value);
-
-            return new ShellSettings {
-                Name = GetValue(fields, "Name"),
-                DataProvider = GetValue(fields, "DataProvider"),
-                DataConnectionString = GetValue(fields, "DataConnectionString")
-            };
-        }
-
-        static string GetValue(
-            IDictionary<string, DataItem> fields,
-            string key) {
-
-            DataItem value;
-            return fields.TryGetValue(key, out value) ? value.ToString() : null;
-        }
-
-        static string ComposeSettings(IShellSettings shellSettings) {
-            if (shellSettings == null)
-                return "";
-
-            var settingsBuilder = new StringBuilder();
-
-            settingsBuilder.AppendLine(string.Format("Name: {0}", shellSettings.Name));
-            settingsBuilder.AppendLine(string.Format("DataProvider: {0}", shellSettings.DataProvider));
-
-            if (!string.IsNullOrEmpty(shellSettings.DataConnectionString))
-                settingsBuilder.AppendLine(string.Format("DataConnectionString: {0}", shellSettings.DataConnectionString));
-
-            return settingsBuilder.ToString();
-        }
-    }
-}

src/Orchard/Orchard.csproj

@@ -101,6 +101,10 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\yaml\Yaml.dll</HintPath>
     </Reference>
+    <Reference Include="YamlSerializer, Version=0.9.0.2, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\yaml\YamlSerializer.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Data\SessionLocator.cs" />