public bool TryAddDescriptorForLocation(Guid mountPointId, out IReadOnlyList <IInstallUnitDescriptor> descriptorList) { IMountPoint mountPoint = null; try { if (!((SettingsLoader)(_environmentSettings.SettingsLoader)).TryGetMountPointFromId(mountPointId, out mountPoint)) { descriptorList = null; return(false); } if (InstallUnitDescriptorFactory.TryCreateFromMountPoint(_environmentSettings, mountPoint, out descriptorList)) { foreach (IInstallUnitDescriptor descriptor in descriptorList) { AddOrReplaceDescriptor(descriptor); } } else { return(false); } } finally { if (mountPoint != null) { _environmentSettings.SettingsLoader.ReleaseMountPoint(mountPoint); } } return(true); }
public FileSystemMountPoint(IEngineEnvironmentSettings environmentSettings, IMountPoint parent, MountPointInfo info) { EnvironmentSettings = environmentSettings; _paths = new Paths(environmentSettings); Info = info; Root = new FileSystemDirectory(this, "/", "", info.Place); }
private bool TryCopyForNonFileSystemBasedMountPoints(IMountPoint mountPoint, string sourceLocation, string targetBasePath, bool expandIfArchive, out string diskPath) { string targetPath = Path.Combine(targetBasePath, Path.GetFileName(sourceLocation)); try { if (expandIfArchive) { mountPoint.Root.CopyTo(targetPath); } else { _paths.CreateDirectory(targetBasePath); // creates Packages/ or Content/ if needed _paths.Copy(sourceLocation, targetPath); } } catch (IOException) { _environmentSettings.Host.LogDiagnosticMessage($"Error copying scanLocation: {sourceLocation} into the target dir: {targetPath}", "Install"); diskPath = null; return(false); } diskPath = targetPath; return(true); }
public MockFile(string fullpath, IMountPoint mountPoint) { FullPath = fullpath; Name = fullpath.Trim('/').Split('/').Last(); MountPoint = mountPoint; Exists = false; }
public void CanValidatePostActionWithDefaultInstructionLocalization() { SimpleConfigModel baseConfig = new SimpleConfigModel() { Identity = "Test", PostActionModels = new List <PostActionModel> { new PostActionModel() { Id = "pa0", Description = "text", ActionId = Guid.NewGuid(), ManualInstructionInfo = new List <ManualInstructionModel>() { new ManualInstructionModel(null, "my text") } }, } }; IEngineEnvironmentSettings environmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true); string tempFolder = _environmentSettingsHelper.CreateTemporaryFolder(); string localizationFile = string.Format(DefaultLocalizeConfigRelativePath, "de-DE"); WriteFile(Path.Combine(tempFolder, localizationFile), "{ \"postActions/pa0/manualInstructions/default/text\": \"localized\" }", environmentSettings); using IMountPoint mountPoint = GetMountPointForPath(tempFolder, environmentSettings); var runnableProjectConfig = new RunnableProjectConfig(environmentSettings, A.Fake <IGenerator>(), baseConfig); var localizationModel = LocalizationModelDeserializer.Deserialize(mountPoint.FileInfo(localizationFile) !); Assert.True(runnableProjectConfig.VerifyLocalizationModel(localizationModel)); runnableProjectConfig.ConfigurationModel.Localize(localizationModel); runnableProjectConfig.PostActionModels.Single(model => model.Id == "pa0" && model.ManualInstructionInfo[0].Text == "localized"); }
public IList <ITemplate> GetTemplatesAndLangpacksFromDir(IMountPoint source, out IList <ILocalizationLocator> localizations) { IDirectory folder = source.Root; Regex localeFileRegex = new Regex(@" ^ (?<locale> [a-z]{2} (?:-[A-Z]{2})? ) \." + Regex.Escape(TemplateConfigFileName) + "$" , RegexOptions.IgnorePatternWhitespace); IList <ITemplate> templateList = new List <ITemplate>(); localizations = new List <ILocalizationLocator>(); foreach (IFile file in folder.EnumerateFiles("*" + TemplateConfigFileName, SearchOption.AllDirectories)) { if (string.Equals(file.Name, TemplateConfigFileName, StringComparison.OrdinalIgnoreCase)) { IFile hostConfigFile = file.MountPoint.EnvironmentSettings.SettingsLoader.FindBestHostTemplateConfigFile(file); if (TryGetTemplateFromConfigInfo(file, out ITemplate template, hostTemplateConfigFile: hostConfigFile)) { templateList.Add(template); } continue; } Match localeMatch = localeFileRegex.Match(file.Name); if (localeMatch.Success) { string locale = localeMatch.Groups["locale"].Value; if (TryGetLangPackFromFile(file, out ILocalizationModel locModel)) { ILocalizationLocator locator = new LocalizationLocator() { Locale = locale, MountPointId = source.Info.MountPointId, ConfigPlace = file.FullPath, Identity = locModel.Identity, Author = locModel.Author, Name = locModel.Name, Description = locModel.Description, ParameterSymbols = locModel.ParameterSymbols }; localizations.Add(locator); } continue; } } return(templateList); }
public void CanHandlePostActions() { IEngineEnvironmentSettings environmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true); SettingsFilePaths paths = new SettingsFilePaths(environmentSettings); Guid postAction1 = Guid.NewGuid(); Guid postAction2 = Guid.NewGuid(); ITemplate template = A.Fake <ITemplate>(); A.CallTo(() => template.Identity).Returns("testIdentity"); A.CallTo(() => template.Name).Returns("testName"); A.CallTo(() => template.ShortNameList).Returns(new[] { "testShort" }); A.CallTo(() => template.MountPointUri).Returns("testMount"); A.CallTo(() => template.ConfigPlace).Returns(".template.config/template.json"); A.CallTo(() => template.PostActions).Returns(new[] { postAction1, postAction2 }); IMountPoint mountPoint = A.Fake <IMountPoint>(); A.CallTo(() => mountPoint.MountPointUri).Returns("testMount"); ScanResult result = new ScanResult(mountPoint, new[] { template }, Array.Empty <ILocalizationLocator>(), Array.Empty <(string AssemblyPath, Type InterfaceType, IIdentifiedComponent Instance)>()); TemplateCache templateCache = new TemplateCache(new[] { result }, new Dictionary <string, DateTime>(), NullLogger.Instance); WriteObject(environmentSettings.Host.FileSystem, paths.TemplateCacheFile, templateCache); var readCache = new TemplateCache(ReadObject(environmentSettings.Host.FileSystem, paths.TemplateCacheFile), NullLogger.Instance); Assert.Single(readCache.TemplateInfo); var readTemplate = readCache.TemplateInfo[0]; Assert.Equal(new[] { postAction1, postAction2 }, readTemplate.PostActions); }
protected FileSystemInfoBase(IMountPoint mountPoint, string fullPath, string name, FileSystemInfoKind kind) { FullPath = fullPath; Name = name; Kind = kind; MountPoint = mountPoint; }
public FileSystemMountPoint(IEngineEnvironmentSettings environmentSettings, IMountPoint parent, string mountPointUri, string mountPointRootPath) { MountPointUri = mountPointUri; MountPointRootPath = mountPointRootPath; EnvironmentSettings = environmentSettings; _paths = new SettingsFilePaths(environmentSettings); Root = new FileSystemDirectory(this, "/", "", MountPointRootPath); }
public bool TryGetMountPoint(string mountPointUri, out IMountPoint mountPoint) { if (_disposed) { throw new ObjectDisposedException(nameof(SettingsLoader)); } return(MountPointManager.TryDemandMountPoint(mountPointUri, out mountPoint)); }
public ZipFileMountPoint(IEngineEnvironmentSettings environmentSettings, IMountPoint parent, MountPointInfo info, ZipArchive archive) { Parent = parent; EnvironmentSettings = environmentSettings; Archive = archive; Info = info; Root = new ZipFileDirectory(this, "/", ""); }
public void RemoveMountPoint(IMountPoint mountPoint) { _mountPointManager.ReleaseMountPoint(mountPoint); RemoveMountPoints(new Guid[1] { mountPoint.Info.MountPointId }); }
public ZipFileMountPoint(IEngineEnvironmentSettings environmentSettings, IMountPoint parent, string mountPointUri, ZipArchive archive) { MountPointUri = mountPointUri; Parent = parent; EnvironmentSettings = environmentSettings; Archive = archive; Root = new ZipFileDirectory(this, "/", ""); }
public static void AddMountPoint(IMountPoint mountPoint) { _mountPoints[mountPoint.Info.MountPointId] = mountPoint.Info; _userSettings.MountPoints.Add(mountPoint.Info); JObject serialized = JObject.FromObject(_userSettings); Paths.User.SettingsFile.WriteAllText(serialized.ToString()); }
public MountPointScanSource(string location, IMountPoint mountPoint, bool shouldStayInOriginalLocation, bool foundComponents, bool foundTemplates) { Location = location; MountPoint = mountPoint; ShouldStayInOriginalLocation = shouldStayInOriginalLocation; FoundComponents = foundComponents; FoundTemplates = foundTemplates; }
public bool TryMount(IEngineEnvironmentSettings environmentSettings, IMountPoint parent, string mountPointUri, out IMountPoint mountPoint) { if (!Uri.TryCreate(mountPointUri, UriKind.Absolute, out var uri)) { mountPoint = null; return(false); } if (!uri.IsFile) { mountPoint = null; return(false); } ZipArchive archive; if (parent == null) { if (!environmentSettings.Host.FileSystem.FileExists(uri.LocalPath)) { mountPoint = null; return(false); } try { archive = new ZipArchive(environmentSettings.Host.FileSystem.OpenRead(uri.LocalPath), ZipArchiveMode.Read, false); } catch { mountPoint = null; return(false); } } else { IFile file = parent.Root.FileInfo(uri.LocalPath); if (!file.Exists) { mountPoint = null; return(false); } try { archive = new ZipArchive(file.OpenRead(), ZipArchiveMode.Read, false); } catch { mountPoint = null; return(false); } } mountPoint = new ZipFileMountPoint(environmentSettings, parent, mountPointUri, archive); return(true); }
public void CanReadChoiceSymbol( string fileContent, bool errorExpected, string expectedSymbolNamesStr, string expectedSymbolDisplayNamesStr, string expectedDescriptionsStr, string expectedChoicesStr) { IEngineEnvironmentSettings environmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true); string tempFolder = _environmentSettingsHelper.CreateTemporaryFolder(); string localizationFile = string.Format(DefaultLocalizeConfigRelativePath, "de-DE"); WriteFile(Path.Combine(tempFolder, localizationFile), fileContent, environmentSettings); using IMountPoint mountPoint = GetMountPointForPath(tempFolder, environmentSettings); if (!errorExpected) { var localizationModel = LocalizationModelDeserializer.Deserialize(mountPoint.FileInfo(localizationFile) !); Assert.NotNull(localizationModel); if (string.IsNullOrEmpty(expectedSymbolNamesStr)) { Assert.Empty(localizationModel.ParameterSymbols); return; } var expectedSymbolNames = expectedSymbolNamesStr.Split('|'); var expectedDisplayNames = expectedSymbolDisplayNamesStr.Split('|'); var expectedDescriptions = expectedDescriptionsStr.Split('|'); var expectedChoices = expectedChoicesStr?.Split('|'); for (int i = 0; i < expectedSymbolNames.Length; i++) { Assert.True(localizationModel.ParameterSymbols.ContainsKey(expectedSymbolNames[i])); Assert.Equal(expectedDisplayNames[i] == "(null)" ? null : expectedDisplayNames[i], localizationModel.ParameterSymbols[expectedSymbolNames[i]].DisplayName); Assert.Equal(expectedDescriptions[i] == "(null)" ? null : expectedDescriptions[i], localizationModel.ParameterSymbols[expectedSymbolNames[i]].Description); if (expectedChoices == null || expectedChoices[i] == "(null)") { Assert.Empty(localizationModel.ParameterSymbols[expectedSymbolNames[i]].Choices); continue; } var expectedChoicePairs = expectedChoices[i].Split('%'); foreach (var pair in expectedChoicePairs) { var choiceName = pair.Split('*')[0]; var choiceDescription = pair.Split('*')[1]; var choiceDisplayName = pair.Split('*')[2]; Assert.True(localizationModel.ParameterSymbols[expectedSymbolNames[i]].Choices.ContainsKey(choiceName)); Assert.Equal(choiceDescription == "(null)" ? null : choiceDescription, localizationModel.ParameterSymbols[expectedSymbolNames[i]].Choices[choiceName].Description); Assert.Equal(choiceDisplayName == "(null)" ? null : choiceDisplayName, localizationModel.ParameterSymbols[expectedSymbolNames[i]].Choices[choiceName].DisplayName); } } } else { Assert.ThrowsAny <Exception>(() => LocalizationModelDeserializer.Deserialize(mountPoint.FileInfo(localizationFile) !)); } }
public MockFile(IDirectory parent, string name, IMountPoint mountPoint, byte[] contents) { FullPath = parent.FullPath + name; Name = name; MountPoint = mountPoint; _contents = contents; Parent = parent; Exists = true; }
public void DisposeMountPoint(IMountPoint mountPoint) { FileSystemMountPoint mp = mountPoint as FileSystemMountPoint; if (mp?.Parent != null) { mp.EnvironmentSettings.SettingsLoader.ReleaseMountPoint(mp.Parent); } }
public bool TryCreateFromMountPoint(IMountPoint mountPoint, bool isPartOfAnOptionalWorkload, out IReadOnlyList <IInstallUnitDescriptor> descriptorList) { descriptorList = new List <IInstallUnitDescriptor>() { new DefaultInstallUnitDescriptor(Guid.NewGuid(), mountPoint.Info.MountPointId, mountPoint.Info.Place, isPartOfAnOptionalWorkload), }; return(true); }
public static IFileSystemInfo ConfigFileSystemInfo(IMountPoint mountPoint, string configFile = null) { if (string.IsNullOrEmpty(configFile)) { configFile = DefaultConfigRelativePath; } return(mountPoint.FileInfo(configFile)); }
public bool TryDemandMountPoint(string mountPointUri, out IMountPoint mountPoint) { if (UnavailableMountPoints.Any(m => m == mountPointUri)) { mountPoint = null; return(false); } mountPoint = new MockMountPoint(EnvironmentSettings); return(true); }
public bool TryDemandMountPoint(Guid mountPointId, out IMountPoint mountPoint) { if (UnavailableMountPoints.Any(m => m.MountPointId == mountPointId)) { mountPoint = null; return(false); } mountPoint = new MockMountPoint(EnvironmentSettings); return(true); }
public bool TryGetMountPointFromPlace(string mountPointPlace, out IMountPoint mountPoint) { if (!TryGetMountPointInfoFromPlace(mountPointPlace, out MountPointInfo info)) { mountPoint = null; return(false); } return(_mountPointManager.TryDemandMountPoint(info.MountPointId, out mountPoint)); }
public IList <ITemplate> GetTemplatesAndLangpacksFromDir(IMountPoint source, out IList <ILocalizationLocator> localizations) { IDirectory folder = source.Root; Regex localeFileRegex = new Regex(@" ^ (?<locale> [a-z]{2} (?:_[a-z]{2})? ) \.netnew\.json $" , RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace); IList <ITemplate> templateList = new List <ITemplate>(); localizations = new List <ILocalizationLocator>(); foreach (IFile file in folder.EnumerateFiles("*.netnew.json", SearchOption.AllDirectories)) { if (string.Equals(file.Name, ".netnew.json", StringComparison.OrdinalIgnoreCase)) { ITemplate template; if (TryGetTemplateFromConfigInfo(file, out template)) { templateList.Add(template); } continue; } Match localeMatch = localeFileRegex.Match(file.Name); if (localeMatch.Success) { string locale = localeMatch.Groups["locale"].Value; ILocalizationModel locModel; if (TryGetLangPackFromFile(file, out locModel)) { ILocalizationLocator locator = new LocalizationLocator() { Locale = locale, MountPointId = source.Info.MountPointId, ConfigPlace = file.FullPath, Identity = locModel.Identity, }; localizations.Add(locator); } continue; } } return(templateList); }
public bool TryMount(IMountPointManager manager, MountPointInfo info, out IMountPoint mountPoint) { if (info.ParentMountPointId != Guid.Empty || !Directory.Exists(info.Place)) { mountPoint = null; return(false); } mountPoint = new FileSystemMountPoint(manager.EnvironmentSettings, info); return(true); }
public void CanReadPostAction( string fileContent, bool errorExpected, string expectedPostActionsStr, string expectedDescriptionsStr, string expectedManualInstructionsStr) { IEngineEnvironmentSettings environmentSettings = _environmentSettingsHelper.CreateEnvironment(virtualize: true); string tempFolder = _environmentSettingsHelper.CreateTemporaryFolder(); string localizationFile = string.Format(DefaultLocalizeConfigRelativePath, "de-DE"); WriteFile(Path.Combine(tempFolder, localizationFile), fileContent, environmentSettings); using IMountPoint mountPoint = GetMountPointForPath(tempFolder, environmentSettings); if (!errorExpected) { var localizationModel = LocalizationModelDeserializer.Deserialize(mountPoint.FileInfo(localizationFile) !); Assert.NotNull(localizationModel); if (string.IsNullOrEmpty(expectedPostActionsStr)) { Assert.Empty(localizationModel.PostActions); return; } var expectedPostActions = expectedPostActionsStr.Split('|'); var expectedDescriptions = expectedDescriptionsStr.Split('|'); var expectedInsturctions = expectedManualInstructionsStr?.Split('|'); for (int i = 0; i < expectedPostActions.Length; i++) { Assert.True(localizationModel.PostActions.ContainsKey(expectedPostActions[i])); Assert.Equal(expectedDescriptions[i] == "(null)" ? null : expectedDescriptions[i], localizationModel.PostActions[expectedPostActions[i]].Description); if (expectedInsturctions == null || expectedInsturctions[i] == "(null)") { Assert.Empty(localizationModel.PostActions[expectedPostActions[i]].Instructions); continue; } var expectedInstructionPairs = expectedInsturctions[i].Split('%'); foreach (var pair in expectedInstructionPairs) { var id = pair.Split('*')[0]; var text = pair.Split('*')[1]; Assert.True(localizationModel.PostActions[expectedPostActions[i]].Instructions.ContainsKey(id)); Assert.Equal(text == "(null)" ? null : text, localizationModel.PostActions[expectedPostActions[i]].Instructions[id]); } } } else { Assert.ThrowsAny <Exception>(() => LocalizationModelDeserializer.Deserialize(mountPoint.FileInfo(localizationFile) !)); } }
public MockDirectory(string fullPath, IMountPoint mountPoint) { if (fullPath[fullPath.Length - 1] != '/') { fullPath += '/'; } FullPath = fullPath; Name = fullPath.Trim('/').Split('/').Last(); MountPoint = mountPoint; Exists = false; }
public bool TryDemandMountPoint(Guid mountPointId, out IMountPoint mountPoint) { using (Timing.Over(EnvironmentSettings.Host, "Get mount point")) { if (EnvironmentSettings.SettingsLoader.TryGetMountPointInfo(mountPointId, out MountPointInfo info)) { return(TryDemandMountPoint(info, out mountPoint)); } mountPoint = null; return(false); } }
public void AddMountPoint(IMountPoint mountPoint) { if (_mountPoints.Values.Any(x => string.Equals(x.Place, mountPoint.Info.Place) && x.ParentMountPointId == mountPoint.Info.ParentMountPointId)) { return; } _mountPoints[mountPoint.Info.MountPointId] = mountPoint.Info; _userSettings.MountPoints.Add(mountPoint.Info); JObject serialized = JObject.FromObject(_userSettings); _paths.WriteAllText(_paths.User.SettingsFile, serialized.ToString()); }
public void AddMountPoint(IMountPoint mountPoint) { if (mountPoint == null) { throw new ArgumentNullException(nameof(mountPoint), "The mountPoint argument can not be null."); } if (this.MountPoints.Contains(mountPoint)) { return; } this.MountPoints.Add(mountPoint); }
public void AddMountPoint(IMountPoint mountPoint) { throw new NotImplementedException(); }