/// <summary> /// Creates manifest nodes for a set of file system elements. /// </summary> /// <param name="entries">The file system elements to create nodes for.</param> /// <returns>The nodes for the elements.</returns> private IEnumerable <ManifestNode> GetNodes(IEnumerable <FileSystemInfo> entries) { var externalXbits = FlagUtils.GetFiles(FlagUtils.XbitFile, TargetDir); var externalSymlinks = FlagUtils.GetFiles(FlagUtils.SymlinkFile, TargetDir); // Iterate through the directory listing to build a list of manifets entries var nodes = new List <ManifestNode>(); foreach (var entry in entries) { CancellationToken.ThrowIfCancellationRequested(); var file = entry as FileInfo; if (file != null) { // Don't include manifest management files in manifest if (file.Name == Manifest.ManifestFile || file.Name == FlagUtils.XbitFile || file.Name == FlagUtils.SymlinkFile) { continue; } nodes.Add(GetFileNode(file, Format, externalXbits, externalSymlinks)); UnitsProcessed += file.Length; } else { var directory = entry as DirectoryInfo; if (directory != null) { nodes.Add(GetDirectoryNode(directory, Format, Path.GetFullPath(TargetDir))); } } } return(nodes); }
public void TestApplyRecipeSingleFile() { using (var singleFile = new TemporaryFile("0install-unit-tests")) using (var archiveFile = new TemporaryFile("0install-unit-tests")) { File.WriteAllText(singleFile, "data"); typeof(ArchiveExtractorTest).CopyEmbeddedToFile("testArchive.zip", archiveFile); var downloadedFiles = new[] { archiveFile, singleFile }; var recipe = new Recipe { Steps = { new Archive { MimeType = Archive.MimeTypeZip }, new SingleFile{ Destination = "subdir2/executable" } } }; using (TemporaryDirectory recipeDir = recipe.Apply(downloadedFiles, new SilentTaskHandler())) { // /subdir2/executable [!X] string path = Path.Combine(recipeDir, "subdir2", "executable"); File.Exists(path).Should().BeTrue(because: "File should exist: " + path); File.ReadAllText(path).Should().Be("data"); File.GetLastWriteTimeUtc(path).ToUnixTime() .Should().Be(0, because: "Single files should be set to Unix epoch"); if (!UnixUtils.IsUnix) { FlagUtils.GetFiles(FlagUtils.XbitFile, recipeDir).Should().BeEmpty(); } } } }
public void TestApplyRecipeArchiv() { using (var archiveFile = new TemporaryFile("0install-unit-tests")) { typeof(ExtractorTest).WriteEmbeddedFile("testArchive.zip", archiveFile); var downloadedFiles = new[] { archiveFile }; var recipe = new Recipe { Steps = { new Archive { MimeType = Archive.MimeTypeZip, Destination = "subDir" } } }; using (TemporaryDirectory recipeDir = recipe.Apply(downloadedFiles, new SilentTaskHandler())) { // /dest/symlink [S] string path = new[] { recipeDir, "subDir", "symlink" }.Aggregate(Path.Combine); Assert.IsTrue(File.Exists(path), "File should exist: " + path); if (!UnixUtils.IsUnix) { CollectionAssert.AreEquivalent(new[] { path }, FlagUtils.GetFiles(FlagUtils.SymlinkFile, recipeDir)); } // /dest/subdir2/executable [deleted] path = new[] { recipeDir, "subDir", "subdir2", "executable" }.Aggregate(Path.Combine); Assert.IsTrue(File.Exists(path), "File should exist: " + path); if (!UnixUtils.IsUnix) { CollectionAssert.AreEquivalent(new[] { path }, FlagUtils.GetFiles(FlagUtils.XbitFile, recipeDir)); } } } }
protected virtual string VerifyAndAdd(string tempID, ManifestDigest expectedDigest, ITaskHandler handler) { #region Sanity checks if (string.IsNullOrEmpty(tempID)) { throw new ArgumentNullException(nameof(tempID)); } if (handler == null) { throw new ArgumentNullException(nameof(handler)); } #endregion // Determine the digest method to use string?expectedDigestValue = expectedDigest.Best; if (string.IsNullOrEmpty(expectedDigestValue)) { throw new NotSupportedException(Resources.NoKnownDigestMethod); } // Determine the source and target directories string source = Path.Combine(DirectoryPath, tempID); string target = Path.Combine(DirectoryPath, expectedDigestValue); if (_isUnixFS) { FlagUtils.ConvertToFS(source); } // Calculate the actual digest, compare it with the expected one and create a manifest file VerifyDirectory(source, expectedDigest, handler).Save(Path.Combine(source, Manifest.ManifestFile)); lock (_renameLock) // Prevent race-conditions when adding the same digest twice { if (Directory.Exists(target)) { throw new ImplementationAlreadyInStoreException(expectedDigest); } // Move directory to final store destination try { Directory.Move(source, target); } catch (IOException ex) // TODO: Make language independent when(ex.Message.Contains("already exists")) { throw new ImplementationAlreadyInStoreException(expectedDigest); } } // Prevent any further changes to the directory if (_useWriteProtection) { EnableWriteProtection(target); } return(target); }
public void TestRename() { using (var flagFile = new TemporaryFile("0install-unit-tests")) { File.WriteAllText(flagFile, "/dir/file1\n/dir/file2\n/dir2/file\n"); FlagUtils.Rename(flagFile, "dir", "new_dir"); File.ReadAllText(flagFile).Should().Be("/new_dir/file1\n/new_dir/file2\n/dir2/file\n"); } }
/// <summary> /// Applies a <see cref="RenameStep"/> to a <see cref="TemporaryDirectory"/>. /// </summary> /// <param name="step">The <see cref="Archive"/> to apply.</param> /// <param name="workingDir">The <see cref="TemporaryDirectory"/> to apply the changes to.</param> /// <exception cref="IOException">A path specified in <paramref name="step"/> is illegal.</exception> public static void Apply([NotNull] this RenameStep step, [NotNull] TemporaryDirectory workingDir) { #region Sanity checks if (step == null) { throw new ArgumentNullException(nameof(step)); } if (workingDir == null) { throw new ArgumentNullException(nameof(workingDir)); } #endregion #region Path validation if (string.IsNullOrEmpty(step.Source)) { throw new IOException(string.Format(Resources.RecipeInvalidPath, "(empty)")); } if (string.IsNullOrEmpty(step.Destination)) { throw new IOException(string.Format(Resources.RecipeInvalidPath, "(empty)")); } string source = FileUtils.UnifySlashes(step.Source); string destination = FileUtils.UnifySlashes(step.Destination); if (FileUtils.IsBreakoutPath(source)) { throw new IOException(string.Format(Resources.RecipeInvalidPath, source)); } if (FileUtils.IsBreakoutPath(destination)) { throw new IOException(string.Format(Resources.RecipeInvalidPath, destination)); } #endregion string sourcePath = Path.Combine(workingDir, source); string destinationPath = Path.Combine(workingDir, destination); string parentDir = Path.GetDirectoryName(destinationPath); if (!string.IsNullOrEmpty(parentDir) && !Directory.Exists(parentDir)) { Directory.CreateDirectory(parentDir); } if (Directory.Exists(sourcePath)) { Directory.Move(sourcePath, destinationPath); } else { File.Move(sourcePath, destinationPath); } // Update in flag files as well FlagUtils.Rename(Path.Combine(workingDir, FlagUtils.XbitFile), source, destination); FlagUtils.Rename(Path.Combine(workingDir, FlagUtils.SymlinkFile), source, destination); }
public void TestSet() { using (var flagFile = new TemporaryFile("0install-unit-tests")) { FlagUtils.Set(flagFile, Path.Combine("dir1", "file1")); File.ReadAllText(flagFile).Should().Be("/dir1/file1\n"); FlagUtils.Set(flagFile, Path.Combine("dir2", "file2")); File.ReadAllText(flagFile).Should().Be("/dir1/file1\n/dir2/file2\n"); } }
/// <summary> /// Creates a new directory walking task. /// </summary> /// <param name="sourceDirectory">The path of the directory to walk.</param> protected DirectoryWalkTask([NotNull] string sourceDirectory) { #region Sanity checks if (string.IsNullOrEmpty(sourceDirectory)) { throw new ArgumentNullException(nameof(sourceDirectory)); } #endregion SourceDirectory = new DirectoryInfo(Path.GetFullPath(sourceDirectory)); _isUnixFS = FlagUtils.IsUnixFS(sourceDirectory); }
protected override void CreateSymlink(string linkPath, string linkTarget) { if (_destinationIsUnixFS) { base.CreateSymlink(linkPath, linkTarget); } else { File.WriteAllText(linkPath, linkTarget, Encoding.UTF8); FlagUtils.Set(Path.Combine(DestinationPath, FlagUtils.SymlinkFile), new FileInfo(linkPath).RelativeTo(new DirectoryInfo(DestinationPath))); } }
public void TestGetFiles() { using (var flagDir = new TemporaryDirectory("0install-unit-tests")) { File.WriteAllText(Path.Combine(flagDir, FlagUtils.XbitFile), "/dir1/file1\n/dir2/file2\n"); var expectedResult = new[] { new[] { flagDir, "dir1", "file1" }.Aggregate(Path.Combine), new[] { flagDir, "dir2", "file2" }.Aggregate(Path.Combine) }; CollectionAssert.AreEquivalent(expectedResult, FlagUtils.GetFiles(FlagUtils.XbitFile, flagDir), "Should find .xbit file in same directory"); CollectionAssert.AreEquivalent(expectedResult, FlagUtils.GetFiles(FlagUtils.XbitFile, Path.Combine(flagDir, "subdir")), "Should find .xbit file in parent directory"); } }
public void TestRemove() { using (var flagFile = new TemporaryFile("0install-unit-tests")) { File.WriteAllText(flagFile, "/dir1/file1\n/dir2/file2\n"); FlagUtils.Remove(flagFile, "dir"); File.ReadAllText(flagFile).Should().Be("/dir1/file1\n/dir2/file2\n", because: "Partial match should not change anything"); FlagUtils.Remove(flagFile, Path.Combine("dir1", "file1")); File.ReadAllText(flagFile).Should().Be("/dir2/file2\n"); FlagUtils.Remove(flagFile, "dir2"); File.ReadAllText(flagFile).Should().Be(""); } }
/// <summary> /// Creates a new store using a specific path to a cache directory. /// </summary> /// <param name="path">A fully qualified directory path. The directory will be created if it doesn't exist yet.</param> /// <param name="useWriteProtection">Controls whether implementation directories are made write-protected once added to the cache to prevent unintentional modification (which would invalidate the manifest digests).</param> /// <exception cref="IOException">The directory <paramref name="path"/> could not be created or if the underlying filesystem can not store file-changed times accurate to the second.</exception> /// <exception cref="UnauthorizedAccessException">Creating the directory <paramref name="path"/> is not permitted.</exception> public DirectoryStore([NotNull] string path, bool useWriteProtection = true) { #region Sanity checks if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException("path"); } #endregion try { DirectoryPath = Path.GetFullPath(path); if (!Directory.Exists(DirectoryPath)) { Directory.CreateDirectory(DirectoryPath); } } #region Error handling catch (ArgumentException ex) { // Wrap exception since only certain exception types are allowed throw new IOException(ex.Message, ex); } catch (NotSupportedException ex) { // Wrap exception since only certain exception types are allowed throw new IOException(ex.Message, ex); } #endregion Kind = DetermineKind(DirectoryPath); _useWriteProtection = useWriteProtection; _isUnixFS = FlagUtils.IsUnixFS(DirectoryPath); if (Kind == StoreKind.ReadWrite) { if (!_isUnixFS) { FlagUtils.MarkAsNoUnixFS(DirectoryPath); } if (_useWriteProtection && WindowsUtils.IsWindowsNT) { WriteDeleteInfoFile(DirectoryPath); } } }
public void TestIsUnixFS() { using (var tempDir = new TemporaryDirectory("0install-unit-tests")) { if (UnixUtils.IsUnix) { Assert.IsTrue(FlagUtils.IsUnixFS(tempDir)); FlagUtils.MarkAsNoUnixFS(tempDir); Assert.IsFalse(FlagUtils.IsUnixFS(tempDir)); } else { Assert.IsFalse(FlagUtils.IsUnixFS(tempDir)); } } }
public static void Apply([NotNull] this SingleFile step, [NotNull] TemporaryFile downloadedFile, [NotNull] TemporaryDirectory workingDir, [NotNull] ITaskHandler handler, [CanBeNull] object tag = null) { #region Sanity checks if (step == null) { throw new ArgumentNullException("step"); } if (downloadedFile == null) { throw new ArgumentNullException("downloadedFile"); } if (workingDir == null) { throw new ArgumentNullException("workingDir"); } if (handler == null) { throw new ArgumentNullException("handler"); } #endregion #region Path validation if (string.IsNullOrEmpty(step.Destination)) { throw new IOException(Resources.FileMissingDest); } string destination = FileUtils.UnifySlashes(step.Destination); if (FileUtils.IsBreakoutPath(destination)) { throw new IOException(string.Format(Resources.RecipeInvalidPath, destination)); } #endregion string destinationPath = Path.Combine(workingDir, destination); string parentDir = Path.GetDirectoryName(destinationPath); if (!string.IsNullOrEmpty(parentDir) && !Directory.Exists(parentDir)) { Directory.CreateDirectory(parentDir); } FileUtils.Replace(downloadedFile, destinationPath); File.SetLastWriteTimeUtc(destinationPath, FileUtils.FromUnixTime(0)); // Update in flag files as well FlagUtils.Remove(Path.Combine(workingDir, FlagUtils.XbitFile), destination); FlagUtils.Remove(Path.Combine(workingDir, FlagUtils.SymlinkFile), destination); }
public void TestIsUnixFS() { using (var tempDir = new TemporaryDirectory("0install-unit-tests")) { if (UnixUtils.IsUnix) { FlagUtils.IsUnixFS(tempDir).Should().BeTrue(); FlagUtils.MarkAsNoUnixFS(tempDir); FlagUtils.IsUnixFS(tempDir).Should().BeFalse(); } else { FlagUtils.IsUnixFS(tempDir).Should().BeFalse(); } } }
public void TestGetFiles() { using (var flagDir = new TemporaryDirectory("0install-unit-tests")) { File.WriteAllText(Path.Combine(flagDir, FlagUtils.XbitFile), "/dir1/file1\n/dir2/file2\n"); var expectedResult = new[] { Path.Combine(flagDir, "dir1", "file1"), Path.Combine(flagDir, "dir2", "file2") }; FlagUtils.GetFiles(FlagUtils.XbitFile, flagDir) .Should().BeEquivalentTo(expectedResult, because: "Should find .xbit file in same directory"); FlagUtils.GetFiles(FlagUtils.XbitFile, Path.Combine(flagDir, "subdir")) .Should().BeEquivalentTo(expectedResult, because: "Should find .xbit file in parent directory"); } }
/// <summary> /// Prepares to generate a manifest for a directory in the filesystem. /// </summary> /// <param name="path">The path of the directory to analyze.</param> /// <param name="format">The format of the manifest to generate.</param> public ManifestGenerator([NotNull] string path, [NotNull] ManifestFormat format) { #region Sanity checks if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException("path"); } if (format == null) { throw new ArgumentNullException("format"); } #endregion TargetDir = path.TrimEnd(Path.DirectorySeparatorChar); Format = format; _isUnixFS = FlagUtils.IsUnixFS(TargetDir); }
protected void WriteFile(string name, bool executable = false) { string path = Path.Combine(_sourceDirectory, name); File.WriteAllText(path, Contents); File.SetLastWriteTimeUtc(path, Timestamp); if (executable) { if (UnixUtils.IsUnix) { FileUtils.SetExecutable(path, true); } else { FlagUtils.Set(Path.Combine(_sourceDirectory, FlagUtils.XbitFile), name); } } }
protected override void CopyFile(FileInfo sourceFile, FileInfo destinationFile) { #region Sanity checks if (sourceFile == null) { throw new ArgumentNullException("sourceFile"); } if (destinationFile == null) { throw new ArgumentNullException("destinationFile"); } #endregion base.CopyFile(sourceFile, destinationFile); if (_sourceIsUnixFS && !_destinationIsUnixFS && FileUtils.IsExecutable(sourceFile.FullName)) { FlagUtils.Set(Path.Combine(DestinationPath, FlagUtils.XbitFile), destinationFile.RelativeTo(new DirectoryInfo(DestinationPath))); } }
public void TestApplyRecipeRemove() { using (var archiveFile = new TemporaryFile("0install-unit-tests")) { typeof(ArchiveExtractorTest).CopyEmbeddedToFile("testArchive.zip", archiveFile); var downloadedFiles = new[] { archiveFile }; var recipe = new Recipe { Steps = { new Archive { MimeType = Archive.MimeTypeZip }, new RemoveStep { Path = "symlink" }, new RemoveStep { Path = "subdir2" } } }; using (TemporaryDirectory recipeDir = recipe.Apply(downloadedFiles, new SilentTaskHandler())) { if (!UnixUtils.IsUnix) { FlagUtils.GetFiles(FlagUtils.XbitFile, recipeDir).Should().BeEmpty(); FlagUtils.GetFiles(FlagUtils.SymlinkFile, recipeDir).Should().BeEmpty(); } // /symlink [deleted] string path = Path.Combine(recipeDir, "symlink"); File.Exists(path).Should().BeFalse(because: "File should not exist: " + path); // /subdir2 [deleted] path = Path.Combine(recipeDir, "subdir2"); Directory.Exists(path).Should().BeFalse(because: "Directory should not exist: " + path); } } }
/// <summary> /// Applies a <see cref="RemoveStep"/> to a <see cref="TemporaryDirectory"/>. /// </summary> /// <param name="step">The <see cref="Archive"/> to apply.</param> /// <param name="workingDir">The <see cref="TemporaryDirectory"/> to apply the changes to.</param> /// <exception cref="IOException">A path specified in <paramref name="step"/> is illegal.</exception> public static void Apply([NotNull] this RemoveStep step, [NotNull] TemporaryDirectory workingDir) { #region Sanity checks if (step == null) { throw new ArgumentNullException(nameof(step)); } if (workingDir == null) { throw new ArgumentNullException(nameof(workingDir)); } #endregion #region Path validation if (string.IsNullOrEmpty(step.Path)) { throw new IOException(string.Format(Resources.RecipeInvalidPath, "(empty)")); } string path = FileUtils.UnifySlashes(step.Path); if (FileUtils.IsBreakoutPath(path)) { throw new IOException(string.Format(Resources.RecipeInvalidPath, path)); } #endregion string absolutePath = Path.Combine(workingDir, path); if (Directory.Exists(absolutePath)) { Directory.Delete(absolutePath, recursive: true); } else { File.Delete(absolutePath); } // Update in flag files as well FlagUtils.Remove(Path.Combine(workingDir, FlagUtils.XbitFile), path); FlagUtils.Remove(Path.Combine(workingDir, FlagUtils.SymlinkFile), path); }
public void TestApplyRecipeArchiv() { using (var archiveFile = new TemporaryFile("0install-unit-tests")) { typeof(ArchiveExtractorTest).CopyEmbeddedToFile("testArchive.zip", archiveFile); var downloadedFiles = new[] { archiveFile }; var recipe = new Recipe { Steps = { new Archive { MimeType = Archive.MimeTypeZip, Destination = "subDir" } } }; using (TemporaryDirectory recipeDir = recipe.Apply(downloadedFiles, new SilentTaskHandler())) { // /dest/symlink [S] string path = Path.Combine(recipeDir, "subDir", "symlink"); File.Exists(path).Should().BeTrue(because: "File should exist: " + path); if (UnixUtils.IsUnix) { FileUtils.IsSymlink(path).Should().BeTrue(); } else { CygwinUtils.IsSymlink(path).Should().BeTrue(); } // /dest/subdir2/executable [deleted] path = Path.Combine(recipeDir, "subDir", "subdir2", "executable"); File.Exists(path).Should().BeTrue(because: "File should exist: " + path); if (!UnixUtils.IsUnix) { FlagUtils.GetFiles(FlagUtils.XbitFile, recipeDir).Should().BeEquivalentTo(path); } } } }
/// <summary> /// Iterates over all <paramref name="entries"/> and calls handler methods for them. /// </summary> /// <exception cref="NotSupportedException">A file has illegal properties (e.g. is a device file, has line breaks in the filename, etc.).</exception> /// <exception cref="IOException">There was an error reading a file.</exception> /// <exception cref="UnauthorizedAccessException">You have insufficient rights to read a file.</exception> protected virtual void HandleEntries([NotNull] IEnumerable <FileSystemInfo> entries) { #region Sanity checks if (entries == null) { throw new ArgumentNullException(nameof(entries)); } #endregion var externalXbits = FlagUtils.GetFiles(FlagUtils.XbitFile, SourceDirectory.FullName); var externalSymlinks = FlagUtils.GetFiles(FlagUtils.SymlinkFile, SourceDirectory.FullName); foreach (var entry in entries) { CancellationToken.ThrowIfCancellationRequested(); var file = entry as FileInfo; if (file != null) { if (file.Name == Manifest.ManifestFile || file.Name == FlagUtils.XbitFile || file.Name == FlagUtils.SymlinkFile) { continue; } HandleEntry(file, externalXbits, externalSymlinks); UnitsProcessed += file.Length; } else { var directory = entry as DirectoryInfo; if (directory != null) { HandleEntry(directory); } } } }
public CopyDirectoryPosix(string sourcePath, string destinationPath, bool preserveDirectoryTimestamps = true, bool overwrite = false) : base(sourcePath, destinationPath, preserveDirectoryTimestamps, overwrite) { _sourceIsUnixFS = FlagUtils.IsUnixFS(SourcePath); _destinationIsUnixFS = FlagUtils.IsUnixFS(DestinationPath); }
public void TestApplyRecipeRename() { using (var archiveFile = new TemporaryFile("0install-unit-tests")) { typeof(ExtractorTest).WriteEmbeddedFile("testArchive.zip", archiveFile); var downloadedFiles = new[] { archiveFile }; var recipe = new Recipe { Steps = { new Archive { MimeType = Archive.MimeTypeZip }, new RenameStep { Source = "symlink", Destination = "subdir3/symlink2" }, new RenameStep { Source = "subdir2/executable", Destination = "subdir2/executable2" } } }; using (TemporaryDirectory recipeDir = recipe.Apply(downloadedFiles, new SilentTaskHandler())) { if (!UnixUtils.IsUnix) { CollectionAssert.AreEquivalent( new[] { new[] { recipeDir, "subdir2", "executable2" }.Aggregate(Path.Combine) }, FlagUtils.GetFiles(FlagUtils.XbitFile, recipeDir)); CollectionAssert.AreEquivalent( new[] { new[] { recipeDir, "subdir3", "symlink2" }.Aggregate(Path.Combine) }, FlagUtils.GetFiles(FlagUtils.SymlinkFile, recipeDir)); } // /symlink [deleted] string path = Path.Combine(recipeDir, "symlink"); Assert.IsFalse(File.Exists(path), "File should not exist: " + path); // /subdir3/symlink2 [S] path = new[] { recipeDir, "subdir3", "symlink2" }.Aggregate(Path.Combine); Assert.IsTrue(File.Exists(path), "Missing file: " + path); if (UnixUtils.IsUnix) { Assert.IsTrue(FileUtils.IsSymlink(path), "Not symlink: " + path); } // /subdir2/executable [deleted] path = new[] { recipeDir, "subdir2", "executable" }.Aggregate(Path.Combine); Assert.IsFalse(File.Exists(path), "File should not exist: " + path); // /subdir2/executable2 [X] path = new[] { recipeDir, "subdir2", "executable2" }.Aggregate(Path.Combine); Assert.IsTrue(File.Exists(path), "Missing file: " + path); if (UnixUtils.IsUnix) { Assert.IsTrue(FileUtils.IsExecutable(path), "Not executable: " + path); } } } }
/// <summary> /// Creates a new store using a specific path to a cache directory. /// </summary> /// <param name="directoryPath">A fully qualified directory path. The directory will be created if it doesn't exist yet.</param> /// <param name="useWriteProtection">Controls whether implementation directories are made write-protected once added to the cache to prevent unintentional modification (which would invalidate the manifest digests).</param> /// <exception cref="IOException">The <paramref name="directoryPath"/> could not be created or the underlying filesystem can not store file-changed times accurate to the second.</exception> /// <exception cref="UnauthorizedAccessException">Creating the <paramref name="directoryPath"/> is not permitted.</exception> public DiskImplementationStore(string directoryPath, bool useWriteProtection = true) { #region Sanity checks if (string.IsNullOrEmpty(directoryPath)) { throw new ArgumentNullException(nameof(directoryPath)); } #endregion try { DirectoryPath = Path.GetFullPath(directoryPath); if (!Directory.Exists(DirectoryPath)) { Directory.CreateDirectory(DirectoryPath); } } #region Error handling catch (ArgumentException ex) { // Wrap exception since only certain exception types are allowed throw new IOException(ex.Message, ex); } catch (NotSupportedException ex) { // Wrap exception since only certain exception types are allowed throw new IOException(ex.Message, ex); } #endregion Kind = DetermineKind(DirectoryPath); _useWriteProtection = useWriteProtection; _isUnixFS = FlagUtils.IsUnixFS(DirectoryPath); if (Kind == ImplementationStoreKind.ReadWrite) { try { if (!_isUnixFS) { FlagUtils.MarkAsNoUnixFS(DirectoryPath); } if (_useWriteProtection && WindowsUtils.IsWindowsNT) { WriteDeleteInfoFile(DirectoryPath); } } #region Error handling catch (IOException ex) { // Writing these files is not critical Log.Debug(ex); } catch (UnauthorizedAccessException ex) { // Writing these files is not critical Log.Debug(ex); } #endregion } }