public DiskExtent(ExtentDescriptor descriptor, long diskOffset, FileLocator fileLocator, FileAccess access)
{
_descriptor = descriptor;
_diskOffset = diskOffset;
_fileLocator = fileLocator;
_access = access;
}
public override VirtualDisk CreateDisk(FileLocator locator, string variant, string path, long capacity, Geometry geometry, Dictionary<string, string> parameters)
{
DiskParameters vmdkParams = new DiskParameters();
vmdkParams.Capacity = capacity;
vmdkParams.Geometry = geometry;
switch (variant)
{
case "fixed":
vmdkParams.CreateType = DiskCreateType.MonolithicFlat;
break;
case "dynamic":
vmdkParams.CreateType = DiskCreateType.MonolithicSparse;
break;
case "vmfsfixed":
vmdkParams.CreateType = DiskCreateType.Vmfs;
break;
case "vmfsdynamic":
vmdkParams.CreateType = DiskCreateType.VmfsSparse;
break;
default:
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Unknown VMDK disk variant '{0}'", variant), "variant");
}
return Disk.Initialize(locator, path, vmdkParams);
}
public void TestNotFoundWithException()
{
FileLocator locator = new FileLocator();
locator.Add("testdir/A");
locator.Add("testdir/B");
locator.Add("testdir/B/C");
locator.Find("5");
}
public void TestNotFoundWithoutException()
{
FileLocator locator = new FileLocator();
locator.Add("testdir/A");
locator.Add("testdir/B");
locator.Add("testdir/B/C");
string file = locator.Find("5", false);
file.Should().Be.Null();
}
public override VirtualDisk CreateDisk(FileLocator locator, string variant, string path, long capacity, Geometry geometry, Dictionary<string, string> parameters)
{
switch (variant)
{
case "fixed":
return Disk.InitializeFixed(locator, path, capacity, geometry);
case "dynamic":
return Disk.InitializeDynamic(locator, path, capacity, geometry, DynamicHeader.DefaultBlockSize);
default:
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Unknown VHD disk variant '{0}'", variant), "variant");
}
}
public override VirtualDisk CreateDisk(FileLocator locator, string variant, string path, VirtualDiskParameters diskParameters)
{
switch (variant)
{
case "fixed":
return Disk.InitializeFixed(locator.Open(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None), Ownership.Dispose, diskParameters.Capacity);
case "dynamic":
return Disk.InitializeDynamic(locator.Open(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None), Ownership.Dispose, diskParameters.Capacity);
default:
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Unknown VDI disk variant '{0}'", variant), "variant");
}
}
public override VirtualDisk CreateDisk(FileLocator locator, string variant, string path, VirtualDiskParameters diskParameters)
{
switch (variant)
{
case "fixed":
return Disk.InitializeFixed(locator, path, diskParameters.Capacity, diskParameters.Geometry);
case "dynamic":
throw new NotImplementedException();
default:
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Unknown VHD disk variant '{0}'", variant), "variant");
}
}
public void TestSimpleSearches()
{
FileLocator locator = new FileLocator();
locator.Add("testdir/A");
locator.Add("testdir/B");
locator.Add("testdir/B/C");
var results = new[] { 1, 2, 3, 4 }.Select(x => locator.Find(x.ToString())).ToArray();
StringAssert.StartsWith("testdir/A", results[0]);
StringAssert.StartsWith("testdir/A", results[1]);
StringAssert.StartsWith("testdir/B", results[2]);
StringAssert.StartsWith("testdir/B/C", results[3]);
}
public void GetBytesOfReducedImage_LargePng24bImageReduced()
{
// lady24b.png: PNG image data, 24bit depth, 3632w x 3872h
var path = FileLocator.GetFileDistributedWithApplication(_pathToTestImages, "lady24b.png");
var originalBytes = File.ReadAllBytes(path);
var reducedBytes = BookCompressor.GetBytesOfReducedImage(path);
// Is it reduced, even tho' we switched from 24bit depth to 32bit depth?
Assert.Greater(originalBytes.Length, reducedBytes.Length, "lady24b.png is reduced from 3632x3872");
using (var tempFile = TempFile.WithExtension(Path.GetExtension(path)))
{
RobustFile.WriteAllBytes(tempFile.Path, reducedBytes);
using (var newImage = PalasoImage.FromFileRobustly(tempFile.Path))
Assert.AreEqual(PixelFormat.Format32bppArgb, newImage.Image.PixelFormat, "should have switched to 32bit depth");
}
}
public void TestMakeCorrectAlbumPaths()
{
// ARRANGE
var album = new Album
{
Id = 73,
Performer = new Performer
{
Name = "Foo"
}
};
// ACT
var pathlist = FileLocator.MakeAlbumImagePathlist(album);
// ASSERT
Assert.That(pathlist.All(p => p.EndsWith(@"Foo\Picture\73.jpg")));
}
public static bool CreateSetupMedia(
string UUPPath,
string LanguageCode,
string OutputMediaPath,
string OutputWindowsREPath,
Common.CompressionType CompressionType,
ProgressCallback progressCallback = null)
{
bool result = true;
string BaseESD = null;
(result, BaseESD) = FileLocator.LocateFilesForSetupMediaCreation(UUPPath, LanguageCode, progressCallback);
if (!result)
{
goto exit;
}
WimCompressionType compression = WimCompressionType.None;
switch (CompressionType)
{
case Common.CompressionType.LZMS:
compression = WimCompressionType.Lzms;
break;
case Common.CompressionType.LZX:
compression = WimCompressionType.Lzx;
break;
case Common.CompressionType.XPRESS:
compression = WimCompressionType.Xpress;
break;
}
//
// Build installer
//
result = WindowsInstallerBuilder.BuildSetupMedia(BaseESD, OutputWindowsREPath, OutputMediaPath, compression, RunsAsAdministrator, LanguageCode, progressCallback);
if (!result)
{
goto exit;
}
exit:
return(result);
}
private void ValidateEntryPointPath(string serviceManifestFileName, FileLocator fileLocator, string program, bool isExternalExecutable = false)
{
string entryPointPath = this.GetEntryPointPath(program, serviceManifestFileName);
if (string.IsNullOrEmpty(entryPointPath))
{
ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
TraceType,
serviceManifestFileName,
StringResources.ImageBuilderError_NullOrEmptyError,
"EntryPoint");
}
else if (entryPointPath.IndexOfAny(System.IO.Path.GetInvalidPathChars()) != -1)
{
ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
TraceType,
serviceManifestFileName,
StringResources.ImageBuilderError_InvalidValue,
"EntryPoint",
entryPointPath);
}
else if (System.IO.Path.IsPathRooted(entryPointPath))
{
ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
TraceType,
serviceManifestFileName,
StringResources.ImageBuilderError_RootedEntryPointNotSupported,
entryPointPath);
}
if (isExternalExecutable)
{
ImageBuilder.TraceSource.WriteInfo(
TraceType,
"EntryPointPath {0} is external executable",
entryPointPath);
}
else if (!fileLocator.FileExists(entryPointPath))
{
ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
TraceType,
serviceManifestFileName,
StringResources.ImageBuilderError_EntryPointNotFound,
entryPointPath);
}
}
public void Setup()
{
_folder = new TemporaryFolder("BookCollectionTests");
// _fileLocator = new BloomFileLocator(new CollectionSettings(), new XMatterPackFinder(new string[]{}), new string[] { FileLocator.GetDirectoryDistributedWithApplication("root"), FileLocator.GetDirectoryDistributedWithApplication("factoryCollections") });
_fileLocator = new FileLocator(new string[] { FileLocator.GetDirectoryDistributedWithApplication("BloomBrowserUI"), FileLocator.GetDirectoryDistributedWithApplication("browserui/bookCSS"), FileLocator.GetDirectoryDistributedWithApplication("factoryCollections") });
// _vernacularLibraryCollection = new BookCollection(_folder.Path, BookCollection.CollectionType.TheOneEditableCollection, BookFactory,
// BookStorageFactory, null, null, new CreateFromSourceBookCommand(), new EditBookCommand());
_vernacularLibraryCollection = new Moq.Mock <BookCollection>();
_bookInfoList = new List <Bloom.Book.BookInfo>();
_vernacularLibraryCollection.Setup(x => x.GetBookInfos()).Returns(_bookInfoList);
_storeCollectionList = new Mock <SourceCollectionsList>();
_storeCollectionList.Setup(x => x.GetSourceCollections()).Returns(() => GetStoreCollections());
_librarySettings = new Mock <CollectionSettings>();
_librarySettings.Setup(x => x.CollectionName).Returns(() => "Foo");
}
public void Setup()
{
Logger.Init();
_folder = new TemporaryFolder("ImageServerTests");
LocalizationManager.UseLanguageCodeFolders = true;
var localizationDirectory = FileLocator.GetDirectoryDistributedWithApplication("localization");
LocalizationManager.Create("fr", "Bloom", "Bloom", "1.0.0", localizationDirectory, "SIL/Bloom", null, "", new string[] { });
ErrorReport.IsOkToInteractWithUser = false;
_collectionPath = Path.Combine(_folder.Path, "TestCollection");
var cs = new CollectionSettings(Path.Combine(_folder.Path, "TestCollection.bloomCollection"));
_fileLocator = new BloomFileLocator(cs, new XMatterPackFinder(new string[] { BloomFileLocator.GetInstalledXMatterDirectory() }), ProjectContext.GetFactoryFileLocations(),
ProjectContext.GetFoundFileLocations(), ProjectContext.GetAfterXMatterFileLocations());
}
public void TestBookSpecifiesXMatter(string xmatterBook, string expected, bool useDeviceVersionIfAvailable = false)
{
var fileLocator = new FileLocator(new[] { _factoryXMatter, _testXmatter });
// Test that the XMatterHelper finds a required xmatter setting.
var dom1 = new HtmlDom("<html>" +
"<head>" +
"<meta charset='UTF-8'></meta>" +
"<meta name='BloomFormatVersion' content='2.0'></meta>" +
"<meta name='pageTemplateSource' content='Basic Book'></meta>" +
xmatterBook +
"</head>" +
"<body>" +
"<div id='bloomDataDiv'>" +
"<div data-book='contentLanguage1' lang='*'>en</div>" +
"<div data-book='contentLanguage1Rtl' lang='*'>False</div>" +
"<div data-book='languagesOfBook' lang='*'>English</div>" +
"</div>" +
"</body>" +
"</html>");
XMatterHelper helper1;
if (xmatterBook.Contains("DoesNotExist"))
{
using (new NonFatalProblem.ExpectedByUnitTest())
{
helper1 = new XMatterHelper(dom1, "Factory", fileLocator, useDeviceVersionIfAvailable);
}
}
else
{
helper1 = new XMatterHelper(dom1, "Factory", fileLocator, useDeviceVersionIfAvailable);
}
if (xmatterBook.Contains("DoesNotExist") || string.IsNullOrEmpty(xmatterBook))
{
// An xmatter specification that cannot be found should be removed from the DOM.
// An empty xmatter specification is also removed.
Assert.That(dom1.GetMetaValue("xmatter", null), Is.Null);
}
else
{
// Verify that we may have what we want for the xmatter specification, valid or not.
Assert.That(dom1.GetMetaValue("xmatter", null), Is.Not.Null);
}
Assert.That(helper1.GetStyleSheetFileName(), Is.EqualTo(expected));
}
public LocalizationManager CreateLocalizationManager()
{
var installedStringFileFolder = Path.GetDirectoryName(FileLocator.GetFileDistributedWithApplication("SayMore.es.tmx"));
var relativePathForWritingTmxFiles = Path.Combine(Program.kCompanyAbbrev, Application.ProductName);
LocalizationManager.DeleteOldTmxFiles(kSayMoreLocalizationId,
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), relativePathForWritingTmxFiles),
installedStringFileFolder);
var localizationManager = LocalizationManager.Create(Settings.Default.UserInterfaceLanguage, kSayMoreLocalizationId,
"SayMore", Application.ProductVersion, installedStringFileFolder, relativePathForWritingTmxFiles,
Resources.SayMore, "*****@*****.**", "SayMore", "SIL.Archiving", "SIL.Windows.Forms.FileSystem");
Settings.Default.UserInterfaceLanguage = LocalizationManager.UILanguageId;
return(localizationManager);
}
public void CreateBookOnDiskFromTemplate_FromBasicBook_BookLineageSetToIdOfSourceBook()
{
var source = FileLocator.GetDirectoryDistributedWithApplication("factoryCollections", "Templates", "Basic Book");
string bookFolderPath = _starter.CreateBookOnDiskFromTemplate(source, _projectFolder.Path);
var jsonFile = Path.Combine(bookFolderPath, BookInfo.MetaDataFileName);
Assert.That(File.Exists(jsonFile), "Creating a book should create a metadata json file meta.json");
var metadata = new BookInfo(bookFolderPath, false);
var kIdOfBasicBook = "056B6F11-4A6C-4942-B2BC-8861E62B03B3";
Assert.That(metadata.BookLineage, Is.EqualTo(kIdOfBasicBook));
//we should get our own id, not reuse our parent's
Assert.That(metadata.Id, Is.Not.EqualTo(kIdOfBasicBook), "New book should get its own ID, not reuse parent's");
}
public void FileLoc_GetSonarRunnerProperties()
{
// 0. Set up
string runnerRootDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
string binDir = TestUtils.EnsureTestSpecificFolder(this.TestContext, "bin");
string configDir = TestUtils.EnsureTestSpecificFolder(this.TestContext, "conf");
string runnerFile = Path.Combine(binDir, FileLocator.SonarRunnerFileName);
File.WriteAllText(runnerFile, "dummy runner file");
string configFile = Path.Combine(configDir, "sonar-runner.properties");
File.WriteAllText(configFile, "dummy runner properties file");
using (TestUtilities.EnvironmentVariableScope scope = new TestUtilities.EnvironmentVariableScope())
{
// 1. Runner not found on path -> nothing
scope.SetPath("c:\\");
string actual = FileLocator.FindDefaultSonarRunnerProperties();
Assert.IsNull(actual, "Not expecting the runner properties file to be found");
// 2. Runner found on path but no properties file -> not found
scope.SetPath("c:\\;" + binDir);
File.Delete(configFile);
using (new AssertIgnoreScope())
{
actual = FileLocator.FindDefaultSonarRunnerProperties();
}
Assert.IsNull(actual, "Not expecting the runner properties file to be found");
// 3. Runner found on path and config file exists in expected relative location -> found
// Create the properties file in the expected location
configFile = Path.Combine(configDir, "sonar-runner.properties");
File.WriteAllText(configFile, "dummy runner properties file");
actual = FileLocator.FindDefaultSonarRunnerProperties();
Assert.IsNotNull(actual, "Expecting the runner properties file to be found");
Assert.AreEqual(configFile, actual, "Unexpected file name returned");
}
}
public override VirtualDisk CreateDisk(FileLocator locator, string variant, string path,
VirtualDiskParameters diskParameters)
{
switch (variant)
{
case "fixed":
return(Disk.InitializeFixed(locator, path, diskParameters.Capacity, diskParameters.Geometry));
case "dynamic":
return(Disk.InitializeDynamic(locator, path, diskParameters.Capacity,
FileParameters.DefaultDynamicBlockSize));
default:
throw new ArgumentException(
string.Format(CultureInfo.InvariantCulture, "Unknown VHD disk variant '{0}'", variant),
nameof(variant));
}
}
/// <summary>
/// Play song currently active in the radio
/// </summary>
public async Task PlayCurrentSong()
{
if (_player.SongPlaybackState != PlaybackState.Stop)
{
_player.Stop();
}
var songpath = FileLocator.FindSongPath(_radio.CurrentSong);
try
{
_player.Play(songpath);
}
catch (Exception)
{
await _radio.MoveToNextSongAsync();
}
}
/// <summary>
/// Creates a new virtual disk that is a linked clone of an existing disk.
/// </summary>
/// <param name="fileSystem">The file system to create the VMDK on</param>
/// <param name="path">The path to the new disk</param>
/// <param name="type">The type of the new disk</param>
/// <param name="parent">The disk to clone</param>
/// <returns>The new virtual disk</returns>
public static DiskImageFile InitializeDifferencing(DiscFileSystem fileSystem, string path, DiskCreateType type, string parent)
{
if (type != DiskCreateType.MonolithicSparse && type != DiskCreateType.TwoGbMaxExtentSparse && type != DiskCreateType.VmfsSparse)
{
throw new ArgumentException("Differencing disks must be sparse", "type");
}
string basePath = Path.GetDirectoryName(path);
FileLocator locator = new DiscFileLocator(fileSystem, basePath);
FileLocator parentLocator = locator.GetRelativeLocator(Path.GetDirectoryName(parent));
using (DiskImageFile parentFile = new DiskImageFile(parentLocator, Path.GetFileName(parent), FileAccess.Read))
{
DescriptorFile baseDescriptor = CreateDifferencingDiskDescriptor(type, parentFile, parent);
return(DoInitialize(locator, Path.GetFileName(path), parentFile.Capacity, type, baseDescriptor));
}
}
public TestBook(string testName, string content)
{
_folder = new TemporaryFolder(testName);
BookFolder = _folder.FolderPath;
BookPath = Path.Combine(_folder.FolderPath, testName + ".htm");
File.WriteAllText(BookPath, content);
var settings = CreateDefaultCollectionsSettings();
var codeBaseDir = BloomFileLocator.GetCodeBaseFolder();
// This is minimal...if the content doesn't specify xmatter Bloom defaults to Traditional
// and needs the file locator to know this folder so it can find it.
// May later need to include more folders or allow the individual tests to do so.
var locator = new FileLocator(new string[] { codeBaseDir + "/../browser/templates/xMatter" });
var storage = new BookStorage(BookFolder, locator, new BookRenamedEvent(), settings);
// very minimal...enhance if we need to test something that can really find source collections.
var templatefinder = new SourceCollectionsList();
Book = new Bloom.Book.Book(new BookInfo(BookFolder, true), storage, templatefinder, settings, new PageSelection(), new PageListChangedEvent(), new BookRefreshEvent());
}
public override IDownloadingFile Download(INetDiskFile from, FileLocator to)
{
var downloader = FileTransferService
.GetDownloaderBuilder()
.UseSixCloudConfigure()
.Configure(localPath => localPath.GetUniqueLocalPath(path => File.Exists(path) || File.Exists($"{path}{Constants.DownloadInfoFileExtension}")))
.From(new RemotePathProvider(this, from.Path))
.To(Path.Combine(to, from.Path.FileName))
.Build();
var result = DownloadingFile.Create(this, from, downloader);
SaveDownloadingFile(result);
Logger.Info($"Download: from {from.Path.FileName} to {downloader.Context.LocalPath}. ");
return(result);
}
/// <summary>Get the path and file name of the RAMP executable file</summary>
public static string GetRampExeFileLocation()
{
string exeFile;
const string rampFileExtension = ".ramp";
if (ArchivingDlgViewModel.IsMono)
{
exeFile = FileLocator.LocateInProgramFiles("RAMP", true);
}
else
{
exeFile = FileLocator.GetFromRegistryProgramThatOpensFileType(rampFileExtension) ??
FileLocator.LocateInProgramFiles("ramp.exe", true, "ramp");
}
// make sure the file exists
return(!File.Exists(exeFile) ? null : new FileInfo(exeFile).FullName);
}
/// <summary>
/// This can be used to find the best localized file when there is only one file with the given name,
/// and the file is part of the files distributed with Bloom (i.e., not something in a downloaded template).
/// </summary>
public static string GetBestLocalizableFileDistributedWithApplication(bool existenceOfEnglishVersionIsOptional, params string[] partsOfEnglishFilePath)
{
// at this time, FileLocator does not have a way for the app to actually tell it where to find things distributed
// with the application...
var englishPath = FileLocator.GetFileDistributedWithApplication(true, partsOfEnglishFilePath);
// ... so if it doesn't find it, we have to keep looking
if (string.IsNullOrWhiteSpace(englishPath))
{
//this one will throw if we still can't find it and existenceOfEnglishVersionIsOptional is false
englishPath = BloomFileLocator.GetBrowserFile(existenceOfEnglishVersionIsOptional, partsOfEnglishFilePath);
}
if (!RobustFile.Exists(englishPath))
{
return(englishPath); // just return whatever the original GetFileDistributedWithApplication gave. "", null, whatever it is.
}
return(BloomFileLocator.GetBestLocalizedFile(englishPath));
}
private static void UpdateExtensions()
{
var extensions = new Dictionary <string, string>();
#if !MONO
extensions.Add("eol", ""); //for converting line endings on windows machines
#endif
extensions.Add("hgext.graphlog", ""); //for more easily readable diagnostic logs
extensions.Add("convert", ""); //for catastrophic repair in case of repo corruption
string fixUtfFolder = FileLocator.GetDirectoryDistributedWithApplication(false, "MercurialExtensions", "fixutf8");
if (!string.IsNullOrEmpty(fixUtfFolder))
{
extensions.Add("fixutf8", Path.Combine(fixUtfFolder, "fixutf8.py"));
}
var doc = HgRepository.GetMercurialConfigInMercurialFolder();
SetExtensions(doc, extensions);
doc.SaveAndThrowIfCannot();
}
public DataleveranseXmlGreier()
{
var schemaPath = FileLocator.FindDirectoryInTree(Config.Settings.SchemaSubdirectory);
var xsdPath = Path.Combine(schemaPath, "NiNCoreDataleveranse.xsd");
var xsdGridPath = Path.Combine(schemaPath, "NiNCoreGridleveranse.xsd");
var xsdCachePath = Path.Combine(schemaPath, "cache");
var gmlXmlResolver = CreateGmlXmlResolver(xsdCachePath);
var schemas = new XmlSchemaSet {
XmlResolver = gmlXmlResolver
};
var xsdMarkup = File.ReadAllText(xsdPath);
var xsdDocument = XDocument.Parse(xsdMarkup);
var xsdAttributes = GetAttributes(xsdDocument.Root);
var xsdNamespace = xsdAttributes.ContainsKey("xmlns:nin")
? xsdAttributes["xmlns:nin"].Replace("\"", "")
: "";
var stringReader = new StringReader(xsdMarkup);
var xmlReader = XmlReader.Create(stringReader);
schemas.Add(xsdNamespace, xmlReader);
dataleveranseValiderer = new DataleveranseValiderer(schemas);
schemas = new XmlSchemaSet {
XmlResolver = gmlXmlResolver
};
xsdMarkup = File.ReadAllText(xsdGridPath);
xsdDocument = XDocument.Parse(xsdMarkup);
xsdAttributes = GetAttributes(xsdDocument.Root);
xsdNamespace = xsdAttributes.ContainsKey("xmlns:nin") ? xsdAttributes["xmlns:nin"].Replace("\"", "") : "";
stringReader = new StringReader(xsdMarkup);
xmlReader = XmlReader.Create(stringReader);
schemas.Add(xsdNamespace, xmlReader);
gridValidator = new DataleveranseValiderer(schemas);
}
/// <summary>
/// stick in a json with various settings we want to make available to the javascript
/// </summary>
public static void AddUISettingsToDom(HtmlDom pageDom, CollectionSettings collectionSettings, IFileLocator fileLocator)
{
XmlElement element = pageDom.RawDom.SelectSingleNode("//script[@id='ui-settings']") as XmlElement;
if (element != null)
{
element.ParentNode.RemoveChild(element);
}
element = pageDom.RawDom.CreateElement("script");
element.SetAttribute("type", "text/javascript");
element.SetAttribute("id", "ui-settings");
var d = new Dictionary <string, string>();
//d.Add("urlOfUIFiles", "file:///" + fileLocator.LocateDirectory("ui", "ui files directory"));
if (!String.IsNullOrEmpty(Settings.Default.LastSourceLanguageViewed))
{
d.Add("defaultSourceLanguage", Settings.Default.LastSourceLanguageViewed);
}
d.Add("languageForNewTextBoxes", collectionSettings.Language1Iso639Code);
d.Add("bloomBrowserUIFolder", FileLocator.GetDirectoryDistributedWithApplication("BloomBrowserUI"));
var topics = new[] { "Agriculture", "Animal Stories", "Business", "Culture", "Community Living", "Dictionary", "Environment", "Fiction", "Health", "How To", "Math", "Non Fiction", "Spiritual", "Personal Development", "Primer", "Science", "Traditional Story" };
var builder = new StringBuilder();
builder.Append("[");
foreach (var topic in topics)
{
var localized = LocalizationManager.GetDynamicString("Bloom", "Topics." + topic, topic, "shows in the topics chooser in the edit tab");
builder.Append("\"" + localized + "\", ");
}
builder.Append("]");
d.Add("topics", builder.ToString().Replace(", ]", "]"));
// d.Add("topics", "['Agriculture', 'Animal Stories', 'Business', 'Culture', 'Community Living', 'Dictionary', 'Environment', 'Fiction', 'Health', 'How To', 'Math', 'Non Fiction', 'Spiritual', 'Personal Development', 'Primer', 'Science', 'Tradition']".Replace("'", "\\\""));
element.InnerText = String.Format("function GetSettings() {{ return {0};}}", JsonConvert.SerializeObject(d));
var head = pageDom.RawDom.SelectSingleNode("//head");
head.InsertAfter(element, head.LastChild);
}
private async Task SavePerformerAsync()
{
var performer = Mapper.Map <Performer>(Performer);
performer.CountryId = SelectedCountryId;
var result = await _performerService.UpdatePerformerAsync(_performer.Id, performer);
if (result.Type != ResultType.Ok)
{
MessageBox.Show(result.Error);
_performer.Name = _initialName;
return;
}
_performer.Country = Mapper.Map <Country>(result.Data.Country);
_performer.ImagePath = FileLocator.GetPerformerImagePath(performer);
RaisePropertyChanged("Performer");
}
/// <summary>
/// Creates the sonar runner file structure required for the
/// product "FileLocator" code to work and create a sonar-runner properties
/// file containing the specified host url setting
/// </summary>
/// <returns>Returns the path of the runner bin directory</returns>
private string CreateRunnerFilesInScope(EnvironmentVariableScope scope)
{
string runnerConfDir = TestUtils.EnsureTestSpecificFolder(this.TestContext, "conf");
string runnerBinDir = TestUtils.EnsureTestSpecificFolder(this.TestContext, "bin");
// Create a sonar-runner.properties file
string runnerExe = Path.Combine(runnerBinDir, "sonar-runner.bat");
File.WriteAllText(runnerExe, "dummy content - only the existence of the file matters");
string configFile = Path.Combine(runnerConfDir, ActualRunnerPropertiesFileName);
File.WriteAllText(configFile, "# dummy properties file content");
scope.SetPath(runnerBinDir);
Assert.IsFalse(string.IsNullOrWhiteSpace(FileLocator.FindDefaultSonarRunnerExecutable()), "Test setup error: failed to locate the created runner executable file");
return(configFile);
}
/// ------------------------------------------------------------------------------------
internal static void Load()
{
if (s_dbAccessInfo == null)
{
// Find the file that contains information about connecting to an FW database.
s_accessInfoFile = FileLocator.GetFileDistributedWithApplication(App.ConfigFolderName, "FwDBAccessInfo.xml");
s_dbAccessInfo = XmlSerializationHelper.DeserializeFromFile <FwDBAccessInfo>(s_accessInfoFile);
}
if (s_dbAccessInfo == null && ShowMsgOnFileLoadFailure)
{
ErrorReport.NotifyUserOfProblem(LocalizationManager.GetString(
"Miscellaneous.Messages.DataSourceReading.LoadingDBAccessInfoErorMsg",
"The file that contains information to access FieldWork databases " +
"older than version 7.x '{0}' is either missing or corrupt. Until " +
"this problem is corrected, FieldWorks data sources cannot be " +
"accessed or added as data sources."), s_accessInfoFile);
}
}
public void Setup()
{
_librarySettings = new Moq.Mock <CollectionSettings>();
_librarySettings.SetupGet(x => x.IsSourceCollection).Returns(false);
_librarySettings.SetupGet(x => x.Language1Iso639Code).Returns("xyz");
_librarySettings.SetupGet(x => x.Language2Iso639Code).Returns("fr");
_librarySettings.SetupGet(x => x.Language3Iso639Code).Returns("es");
_librarySettings.SetupGet(x => x.XMatterPackName).Returns("Factory");
ErrorReport.IsOkToInteractWithUser = false;
_projectFolder = new TemporaryFolder("BookStarterTests_ProjectCollection");
var collectionSettings = new CollectionSettings(Path.Combine(_projectFolder.Path, "test.bloomCollection"));
var xmatterFinder = new XMatterPackFinder(new [] { FileLocator.GetDirectoryDistributedWithApplication("xMatter") });
_fileLocator = new BloomFileLocator(collectionSettings, xmatterFinder, ProjectContext.GetFactoryFileLocations(), ProjectContext.GetFoundFileLocations());
_starter = new BookStarter(_fileLocator, dir => new BookStorage(dir, _fileLocator, new BookRenamedEvent(), collectionSettings), _librarySettings.Object);
_shellCollectionFolder = new TemporaryFolder("BookStarterTests_ShellCollection");
}
internal DiskImageFile(FileLocator locator, string path, FileAccess access)
{
FileShare share = access == FileAccess.Read ? FileShare.Read : FileShare.None;
_fileStream = locator.Open(path, FileMode.Open, access, share);
_ownsStream = Ownership.Dispose;
try
{
_fileLocator = locator.GetRelativeLocator(locator.GetDirectoryFromPath(path));
_fileName = locator.GetFileFromPath(path);
Initialize();
}
catch
{
_fileStream.Dispose();
throw;
}
}
public static void ShowHelpTopic(string topicLink)
{
string helpFilePath = FileLocator.GetFileDistributedWithApplication(true, "WeSay_Helps.chm");
if (String.IsNullOrEmpty(helpFilePath))
{
string commonDataFolder = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
helpFilePath = Path.Combine(commonDataFolder, Path.Combine("wesay", "WeSay_Helps.chm"));
}
if (File.Exists(helpFilePath))
{
//var uri = new Uri(helpFilePath);
Help.ShowHelp(new Label(), helpFilePath, topicLink);
}
else
{
Process.Start("http://wesay.palaso.org/help/");
}
UsageReporter.SendNavigationNotice("Help: " + topicLink);
}
/// <summary>
/// Initializes a new instance of the DiskImageFile class.
/// </summary>
/// <param name="fileLocator">An object to open the file and any extents.</param>
/// <param name="file">The file name.</param>
/// <param name="access">The type of access desired.</param>
internal DiskImageFile(FileLocator fileLocator, string file, FileAccess access)
{
_access = access;
FileAccess fileAccess = FileAccess.Read;
FileShare fileShare = FileShare.Read;
if (_access != FileAccess.Read)
{
fileAccess = FileAccess.ReadWrite;
fileShare = FileShare.None;
}
Stream fileStream = null;
try
{
fileStream = fileLocator.Open(file, FileMode.Open, fileAccess, fileShare);
LoadDescriptor(fileStream);
// For monolithic disks, keep hold of the stream - we won't try to use the file name
// from the embedded descriptor because the file may have been renamed, making the
// descriptor out of date.
if (_descriptor.CreateType == DiskCreateType.StreamOptimized ||
_descriptor.CreateType == DiskCreateType.MonolithicSparse)
{
_monolithicStream = fileStream;
_ownsMonolithicStream = Ownership.Dispose;
fileStream = null;
}
}
finally
{
if (fileStream != null)
{
fileStream.Dispose();
}
}
_fileLocator = fileLocator.GetRelativeLocator(fileLocator.GetDirectoryFromPath(file));
}
internal static DiskImageFile InitializeDynamic(FileLocator locator, string path, long capacity, long blockSize)
{
DiskImageFile result = null;
Stream stream = locator.Open(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
try
{
InitializeDynamicInternal(stream, capacity, blockSize);
result = new DiskImageFile(locator, path, stream, Ownership.Dispose);
stream = null;
}
finally
{
if (stream != null)
{
stream.Dispose();
}
}
return(result);
}
public void Setup()
{
_collectionSettings = new CollectionSettings(new NewCollectionSettings()
{
PathToSettingsFile = CollectionSettings.GetPathForNewSettings(new TemporaryFolder("BookDataTests").Path, "test"),
Language1Iso639Code = "xyz",
Language2Iso639Code = "en",
Language3Iso639Code = "fr"
});
ErrorReport.IsOkToInteractWithUser = false;
var localizationDirectory = FileLocator.GetDirectoryDistributedWithApplication("localization");
_localizationManager = LocalizationManager.Create("fr", "Bloom", "Bloom", "1.0.0", localizationDirectory, "SIL/Bloom",
null, "", new string[] {});
_palasoLocalizationManager = LocalizationManager.Create("fr", "Palaso", "Palaso", "1.0.0", localizationDirectory, "SIL/Bloom",
null, "", new string[] { });
_brandingFolder = new TemporaryFolder("unitTestBrandingFolder");
_pathToBrandingSettingJson = _brandingFolder.Combine("settings.json");
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Get the path and file name of the Arbil executable file
/// </summary>
/// <returns>The full name of the Arbil executable file</returns>
/// ------------------------------------------------------------------------------------
public static string GetExeFileLocation()
{
string exeFile;
if (ArchivingDlgViewModel.IsMono)
{
exeFile = FileLocator.LocateInProgramFiles("RAMP", true);
}
else
{
exeFile = FileLocator.LocateInProgramFiles("arbil-stable.exe", true, "arbil");
}
// make sure the file exists
if (!File.Exists(exeFile))
{
throw new FileNotFoundException("The Arbil executable file was not found.");
}
return(new FileInfo(exeFile).FullName);
}
public override VirtualDisk OpenDisk(FileLocator locator, string path, string extraInfo, Dictionary<string, string> parameters, FileAccess access)
{
VirtualMachine machine = new VirtualMachine(locator.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read), Ownership.Dispose);
int diskIndex;
if (!int.TryParse(extraInfo, out diskIndex))
{
diskIndex = 0;
}
int i = 0;
foreach (var disk in machine.Disks)
{
if (i == diskIndex)
{
return disk;
}
++i;
}
return null;
}
public override VirtualDisk CreateDisk(FileLocator locator, string variant, string path, VirtualDiskParameters diskParameters)
{
return Disk.Initialize(locator.Open(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None), Ownership.Dispose, diskParameters.Capacity, diskParameters.Geometry);
}
public override VirtualDisk OpenDisk(FileLocator locator, string path, FileAccess access)
{
FileShare share = access == FileAccess.Read ? FileShare.Read : FileShare.None;
return new Disk(locator.Open(path, FileMode.Open, access, share), Ownership.Dispose);
}
private static DiskImageFile DoInitialize(FileLocator fileLocator, string file, long capacity, DiskCreateType type, DescriptorFile baseDescriptor)
{
if (type == DiskCreateType.MonolithicSparse)
{
// MonolithicSparse is a special case, the descriptor is embedded in the file itself...
using (Stream fs = fileLocator.Open(file, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
long descriptorStart;
CreateExtent(fs, capacity, ExtentType.Sparse, 10 * Sizes.OneKiB, out descriptorStart);
ExtentDescriptor extent = new ExtentDescriptor(ExtentAccess.ReadWrite, capacity / Sizes.Sector, ExtentType.Sparse, file, 0);
fs.Position = descriptorStart * Sizes.Sector;
baseDescriptor.Extents.Add(extent);
baseDescriptor.Write(fs);
}
}
else
{
ExtentType extentType = CreateTypeToExtentType(type);
long totalSize = 0;
List<ExtentDescriptor> extents = new List<ExtentDescriptor>();
if (type == DiskCreateType.MonolithicFlat || type == DiskCreateType.VmfsSparse || type == DiskCreateType.Vmfs)
{
string adornment = "flat";
if(type == DiskCreateType.VmfsSparse)
{
adornment = string.IsNullOrEmpty(baseDescriptor.ParentFileNameHint) ? "sparse" : "delta";
}
string fileName = AdornFileName(file, adornment);
using(Stream fs = fileLocator.Open(fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
CreateExtent(fs, capacity, extentType);
extents.Add(new ExtentDescriptor(ExtentAccess.ReadWrite, capacity / Sizes.Sector, extentType, fileName, 0));
totalSize = capacity;
}
}
else if (type == DiskCreateType.TwoGbMaxExtentFlat || type == DiskCreateType.TwoGbMaxExtentSparse)
{
int i = 1;
while (totalSize < capacity)
{
string adornment;
if (type == DiskCreateType.TwoGbMaxExtentSparse)
{
adornment = string.Format(CultureInfo.InvariantCulture, "s{0:x3}", i);
}
else
{
adornment = string.Format(CultureInfo.InvariantCulture, "{0:x6}", i);
}
string fileName = AdornFileName(file, adornment);
using (Stream fs = fileLocator.Open(fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
long extentSize = Math.Min(2 * Sizes.OneGiB - Sizes.OneMiB, capacity - totalSize);
CreateExtent(fs, extentSize, extentType);
extents.Add(new ExtentDescriptor(ExtentAccess.ReadWrite, extentSize / Sizes.Sector, extentType, fileName, 0));
totalSize += extentSize;
}
++i;
}
}
else
{
throw new NotSupportedException("Creating disks of this type is not supported");
}
using (Stream fs = fileLocator.Open(file, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
baseDescriptor.Extents.AddRange(extents);
baseDescriptor.Write(fs);
}
}
return new DiskImageFile(fileLocator, file, FileAccess.ReadWrite);
}
/// <summary>
/// Creates a new instance from a file on disk.
/// </summary>
/// <param name="path">The path to the disk</param>
/// <param name="access">The desired access to the disk</param>
public DiskImageFile(string path, FileAccess access)
{
_access = access;
FileAccess fileAccess = FileAccess.Read;
FileShare fileShare = FileShare.Read;
if (_access != FileAccess.Read)
{
fileAccess = FileAccess.ReadWrite;
fileShare = FileShare.None;
}
FileStream fileStream = null;
try
{
fileStream = new FileStream(path, FileMode.Open, fileAccess, fileShare);
LoadDescriptor(fileStream);
// For monolithic disks, keep hold of the stream - we won't try to use the file name
// from the embedded descriptor because the file may have been renamed, making the
// descriptor out of date.
if (_descriptor.CreateType == DiskCreateType.StreamOptimized || _descriptor.CreateType == DiskCreateType.MonolithicSparse)
{
_monolithicStream = fileStream;
_ownsMonolithicStream = Ownership.Dispose;
fileStream = null;
}
}
finally
{
if (fileStream != null)
{
fileStream.Dispose();
}
}
_fileLocator = new LocalFileLocator(Path.GetDirectoryName(path));
}
public override VirtualDiskLayer OpenDiskLayer(FileLocator locator, string path, FileAccess access)
{
FileMode mode = (access == FileAccess.Read) ? FileMode.Open : FileMode.OpenOrCreate;
FileShare share = (access == FileAccess.Read) ? FileShare.Read : FileShare.None;
return new DiskImageFile(locator.Open(path, mode, access, share), Ownership.Dispose);
}
public override VirtualDisk OpenDisk(FileLocator locator, string path, FileAccess access)
{
return OpenDisk(locator, path, string.Empty, new Dictionary<string, string>(), access);
}
public override VirtualDisk CreateDisk(FileLocator locator, string variant, string path, VirtualDiskParameters diskParameters)
{
throw new NotSupportedException();
}
/// <summary>
/// Initializes a new instance of the Disk class. Differencing disks are supported.
/// </summary>
/// <param name="file">The file containing the disk</param>
/// <param name="ownsFile">Indicates if the new instance should control the lifetime of the file.</param>
/// <param name="parentLocator">Object used to locate the parent disk</param>
/// <param name="parentPath">Path to the parent disk (if required)</param>
private Disk(DiskImageFile file, Ownership ownsFile, FileLocator parentLocator, string parentPath)
{
_files = new List<DiscUtils.Tuple<DiskImageFile, Ownership>>();
_files.Add(new DiscUtils.Tuple<DiskImageFile, Ownership>(file, ownsFile));
if (file.NeedsParent)
{
_files.Add(
new DiscUtils.Tuple<DiskImageFile, Ownership>(
new DiskImageFile(parentLocator, parentPath, FileAccess.Read),
Ownership.Dispose));
ResolveFileChain();
}
}
/// <summary>
/// Gets the locations of the parent file.
/// </summary>
/// <param name="fileLocator">The file locator to use.</param>
/// <returns>Array of candidate file locations.</returns>
private string[] GetParentLocations(FileLocator fileLocator)
{
if (!NeedsParent)
{
throw new InvalidOperationException("Only differencing disks contain parent locations");
}
if (fileLocator == null)
{
// Use working directory by default
fileLocator = new LocalFileLocator(string.Empty);
}
List<string> absPaths = new List<string>(8);
List<string> relPaths = new List<string>(8);
foreach (var pl in _dynamicHeader.ParentLocators)
{
if (pl.PlatformCode == ParentLocator.PlatformCodeWindowsAbsoluteUnicode
|| pl.PlatformCode == ParentLocator.PlatformCodeWindowsRelativeUnicode)
{
_fileStream.Position = pl.PlatformDataOffset;
byte[] buffer = Utilities.ReadFully(_fileStream, pl.PlatformDataLength);
string locationVal = Encoding.Unicode.GetString(buffer);
if (pl.PlatformCode == ParentLocator.PlatformCodeWindowsAbsoluteUnicode)
{
absPaths.Add(locationVal);
}
else
{
relPaths.Add(fileLocator.ResolveRelativePath(locationVal));
}
}
}
// Order the paths to put absolute paths first
List<string> paths = new List<string>(absPaths.Count + relPaths.Count + 1);
paths.AddRange(absPaths);
paths.AddRange(relPaths);
// As a back-up, try to infer from the parent name...
if (paths.Count == 0)
{
paths.Add(fileLocator.ResolveRelativePath(_dynamicHeader.ParentUnicodeName));
}
return paths.ToArray();
}
internal Disk(FileLocator layerLocator, string path, FileAccess access)
{
_path = path;
_files = new List<ThinkAway.Tuple<VirtualDiskLayer, Ownership>>();
_files.Add(new ThinkAway.Tuple<VirtualDiskLayer, Ownership>(new DiskImageFile(layerLocator, path, access), Ownership.Dispose));
ResolveFileChain();
}
public override VirtualDisk CreateDisk(FileLocator locator, string variant, string path, long capacity, Geometry geometry, Dictionary<string, string> parameters)
{
return Disk.Initialize(locator.Open(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None), Ownership.Dispose, capacity, geometry);
}
public override VirtualDisk OpenDisk(FileLocator locator, string path, FileAccess access)
{
OpticalFormat format = path.EndsWith(".bin", StringComparison.OrdinalIgnoreCase) ? OpticalFormat.Mode2 : OpticalFormat.Mode1;
FileShare share = access == FileAccess.Read ? FileShare.Read : FileShare.None;
return new Disc(locator.Open(path, FileMode.Open, access, share), Ownership.Dispose, format);
}
public override VirtualDisk CreateDisk(FileLocator locator, string variant, string path, VirtualDiskParameters diskParameters)
{
DiskParameters vmdkParams = new DiskParameters(diskParameters);
vmdkParams.CreateType = VariantToCreateType(variant);
return Disk.Initialize(locator, path, vmdkParams);
}
public override VirtualDiskLayer OpenDiskLayer(FileLocator locator, string path, FileAccess access)
{
return null;
}
internal static Disk InitializeDynamic(FileLocator fileLocator, string path, long capacity, Geometry geometry, long blockSize)
{
return new Disk(DiskImageFile.InitializeDynamic(fileLocator, path, capacity, geometry, blockSize), Ownership.Dispose);
}
/// <summary>
/// Initializes a new instance of the Disk class. Differencing disks are supported.
/// </summary>
/// <param name="locator">The locator to access relative files</param>
/// <param name="path">The path to the disk image</param>
/// <param name="access">The access requested to the disk</param>
internal Disk(FileLocator locator, string path, FileAccess access)
{
DiskImageFile file = new DiskImageFile(locator, path, access);
_files = new List<DiscUtils.Tuple<DiskImageFile, Ownership>>();
_files.Add(new DiscUtils.Tuple<DiskImageFile, Ownership>(file, Ownership.Dispose));
ResolveFileChain();
}
internal static Disk Initialize(FileLocator fileLocator, string path, DiskParameters parameters)
{
return new Disk(DiskImageFile.Initialize(fileLocator, path, parameters), Ownership.Dispose);
}
internal static Disk InitializeFixed(FileLocator fileLocator, string path, long capacity, Geometry geometry)
{
return new Disk(DiskImageFile.InitializeFixed(fileLocator, path, capacity, geometry), Ownership.Dispose);
}
/// <summary>
/// Creates a new virtual disk at the specified path.
/// </summary>
/// <param name="fileLocator">The object used to locate / create the component files.</param>
/// <param name="path">The name of the VMDK to create.</param>
/// <param name="parameters">The desired parameters for the new disk.</param>
/// <returns>The newly created disk image</returns>
internal static DiskImageFile Initialize(FileLocator fileLocator, string path, DiskParameters parameters)
{
if (parameters.Capacity <= 0)
{
throw new ArgumentException("Capacity must be greater than zero", "parameters");
}
Geometry geometry = parameters.Geometry ?? DefaultGeometry(parameters.Capacity);
Geometry biosGeometry;
if (parameters.BiosGeometry != null)
{
biosGeometry = parameters.BiosGeometry;
}
else
{
biosGeometry = Geometry.MakeBiosSafe(geometry, parameters.Capacity);
}
DiskAdapterType adapterType = (parameters.AdapterType == DiskAdapterType.None) ? DiskAdapterType.LsiLogicScsi : parameters.AdapterType;
DiskCreateType createType = (parameters.CreateType == DiskCreateType.None) ? DiskCreateType.MonolithicSparse : parameters.CreateType;
DescriptorFile baseDescriptor = CreateSimpleDiskDescriptor(geometry, biosGeometry, createType, adapterType);
return DoInitialize(fileLocator, path, parameters.Capacity, createType, baseDescriptor);
}
public override VirtualDiskLayer OpenDiskLayer(FileLocator locator, string path, FileAccess access)
{
return new DiskImageFile(locator, path, access);
}
public override VirtualDisk OpenDisk(FileLocator locator, string path, FileAccess access)
{
return new Disk(locator, path, access);
}
