public Repository OpenRepositoryWithRetry(IAbsoluteDirectoryPath path, bool createWhenNotExisting = false, Action failAction = null) { if (createWhenNotExisting && !path.Exists) return new Repository(path, createWhenNotExisting); using (var autoResetEvent = new AutoResetEvent(false)) using (var fileSystemWatcher = new FileSystemWatcher(path.ToString(), "*.lock") { EnableRaisingEvents = true }) { var lockFile = path.GetChildFileWithName(Repository.LockFile); var fp = Path.GetFullPath(lockFile.ToString()); fileSystemWatcher.Deleted += (o, e) => { if (Path.GetFullPath(e.FullPath) == fp) autoResetEvent.Set(); }; while (true) { using (var timer = UnlockTimer(lockFile, autoResetEvent)) { try { return new Repository(path, createWhenNotExisting); } catch (RepositoryLockException) { if (failAction != null) failAction(); timer.Start(); autoResetEvent.WaitOne(); lock (timer) timer.Stop(); autoResetEvent.Reset(); } } } } }
public ContentPaths(IAbsoluteDirectoryPath path, IAbsoluteDirectoryPath repositoryPath) { Contract.Requires<ArgumentNullException>(path != null); Contract.Requires<ArgumentNullException>(repositoryPath != null); Path = path; RepositoryPath = repositoryPath; }
public ContentEngineContent(Guid networkId, Guid id, bool isInstalled, IAbsoluteDirectoryPath path, Guid gameId) { NetworkId = networkId; Id = id; IsInstalled = isInstalled; PathInternal = path; GameId = gameId; }
public IEnumerable<string> Enumerate(IAbsoluteDirectoryPath path) { Contract.Requires<ArgumentNullException>(path != null); return Tools.FileUtil.GetFiles(path, "*.bisign") .Select(GetSignatureFromFileName).Where(x => !string.IsNullOrWhiteSpace(x)) .Select(x => x.ToLower()) .Distinct(); }
async Task<bool> TryCheckUac(IAbsoluteDirectoryPath mp, IAbsoluteFilePath path) { Exception ex; try { mp.MakeSurePathExists(); if (path.Exists) File.Delete(path.ToString()); using (File.CreateText(path.ToString())) {} File.Delete(path.ToString()); return false; } catch (UnauthorizedAccessException e) { ex = e; } catch (Exception e) { this.Logger().FormattedWarnException(e); return false; } var report = await UserErrorHandler.HandleUserError(new UserErrorModel("Restart the application elevated?", $"The application failed to write to the path, probably indicating permission issues\nWould you like to restart the application Elevated?\n\n {mp}", RecoveryCommands.YesNoCommands, null, ex)) == RecoveryOptionResultModel.RetryOperation; if (!report) return false; RestartWithUacInclEnvironmentCommandLine(); return true; }
public static async Task<PackageManager> Create(Repository repo, IAbsoluteDirectoryPath workDir, bool createWhenNotExisting = false, string remote = null) { var pm = new PackageManager(repo, workDir, createWhenNotExisting, remote); await repo.RefreshRemotes().ConfigureAwait(false); return pm; }
public PackageManager(Repository repo, IAbsoluteDirectoryPath workDir, bool createWhenNotExisting = false, string remote = null) { Contract.Requires<ArgumentNullException>(repo != null); Contract.Requires<ArgumentNullException>(workDir != null); WorkDir = workDir; Repo = repo; StatusRepo = new StatusRepo(); Settings = new PackageManagerSettings(); Repository.Factory.HandlePathRequirements(WorkDir, Repo); if (!WorkDir.Exists) { if (!createWhenNotExisting) throw new Exception("Workdir doesnt exist"); WorkDir.MakeSurePathExists(); } if (!string.IsNullOrWhiteSpace(remote)) { var config = Repository.DeserializeJson<RepositoryConfigDto>( FetchString(Tools.Transfer.JoinUri(new Uri(remote), "config.json"))); if (config.Uuid == Guid.Empty) throw new Exception("Invalid remote, does not contain an UUID"); Repo.AddRemote(config.Uuid, remote); Repo.Save(); } Repository.Log("Opening repository at: {0}. Working directory at: {1}", Repo.RootPath, WorkDir); _remote = remote; }
public RealVirtualityLauncher(IMediator mediator, IGameLauncherProcess processManager, IPathConfiguration pathConfiguration, IFileWriter writer) : base(mediator, processManager) { Contract.Requires<ArgumentNullException>(writer != null); _writer = writer; _parPath = pathConfiguration.LocalDataPath.GetChildDirectoryWithName("games"); }
public static async Task<BundleManager> Create(Repository repo, IAbsoluteDirectoryPath workDir, bool createWhenNotExisting = false, string remote = null) { var packageManager = await PackageManager.Create(repo, workDir, createWhenNotExisting, remote).ConfigureAwait(false); return new BundleManager(packageManager); }
public VariablePathResolvingStatus TryResolve(IEnumerable<KeyValuePair<string, string>> variables, out IAbsoluteDirectoryPath resolvedPath, out IReadOnlyList<string> unresolvedVariables) { Argument.IsNotNull(nameof(variables), variables); string path; if (!TryResolve(variables, out path, out unresolvedVariables)) { resolvedPath = null; return VariablePathResolvingStatus.UnresolvedVariable; } if (!path.IsValidAbsoluteDirectoryPath()) { resolvedPath = null; return VariablePathResolvingStatus.CannotConvertToAbsolutePath; } resolvedPath = path.ToAbsoluteDirectoryPath(); return VariablePathResolvingStatus.Success; }
static IEnumerable<IAbsoluteDirectoryPath> ExistingMods(IAbsoluteDirectoryPath[] paths, params string[] mods) { return paths.Any() ? mods.Select( x => paths.Select(path => path.GetChildDirectoryWithName(x)).FirstOrDefault(p => p.Exists)) .Where(x => x != null) : Enumerable.Empty<IAbsoluteDirectoryPath>(); }
private static IAbsoluteFilePath GetNetEntryFilePath(IAbsoluteDirectoryPath netEntryPath, string asName) { var en = netEntryPath ?? AppContext.BaseDirectory.ToAbsoluteDirectoryPath(); var dll = en.GetChildFileWithName(asName + ".dll"); var netEntryFilePath = dll.Exists ? dll : en.GetChildFileWithName(asName + ".exe"); //_entryAssembly.Location.ToAbsoluteFilePath(); return netEntryFilePath; }
async Task CheckoutBundles(IAbsoluteDirectoryPath path, Repository repo, string[] packages) { var pm = await BundleManager.Create(repo, path).ConfigureAwait(false); ConfirmOperationMode(pm.Repo, 2); var scope = BundleScope.All; if (!string.IsNullOrWhiteSpace(Scope)) { if (!Enum.TryParse(Scope, true, out scope)) throw new ConsoleHelpAsException("Invalid scope: " + Scope); } System.Console.WriteLine("Querying Bundles: {0}. Scope: {1}, IncludeOptional: {2}. Additional: {3}", String.Join(", ", packages), scope, IncludeOptional, Additional); Package[] packs; using (new ConsoleProgress(pm.PackageManager.StatusRepo)) { packs = await pm.Checkout(new Bundle("selected") { Dependencies = packages.Select(x => new Dependency(x)) .ToDictionary(x => x.Name, x => x.GetConstraints()), Required = Additional == null ? new Dictionary<string, string>() : Additional.Split(',') .Select(x => new Dependency(x)) .ToDictionary(x => x.Name, x => x.GetConstraints()) }, IncludeOptional, scope, UseVersionedPackageFolders).ConfigureAwait(false); } System.Console.WriteLine("\nSuccesfully checked out {0} packages", string.Join(", ", packs.Count())); }
public string ProcessUserconfig(IAbsoluteDirectoryPath modPath, IAbsoluteDirectoryPath gamePath, string exisitingChecksum, bool force = true) { Contract.Requires<ArgumentNullException>(modPath != null); Contract.Requires<ArgumentNullException>(gamePath != null); var backupAndClean = force; var path = GetUserconfigPath(modPath); if (!File.Exists(path) && !Directory.Exists(path)) return null; this.Logger().Info("Found userconfig to process at " + path); var checksum = GetConfigChecksum(path); if (checksum != exisitingChecksum) backupAndClean = true; var uconfig = gamePath.GetChildDirectoryWithName("userconfig"); var uconfigPath = uconfig.GetChildDirectoryWithName(Mod.GetRepoName(modPath.DirectoryName)); if (backupAndClean) new UserconfigBackupAndClean().ProcessBackupAndCleanInstall(path, gamePath, uconfig, uconfigPath); else new UserconfigUpdater().ProcessMissingFiles(path, gamePath, uconfig, uconfigPath); return checksum; }
public CreateCommand() { IsCommand("create", "Create a Zsync Download Control File"); HasRequiredOption("in|f|folder=", "The folder that you will make a control for", (s) => _folder = s.ToAbsoluteDirectoryPath()); //HasRequiredOption("out=", "The location of the control file", (s) => _file = s.ToAbsoluteFilePath()); HasRequiredOption("url=", "The root url of the download", (s) => _url = s); }
const int WM_USER = 0x0400; //http://msdn.microsoft.com/en-us/library/windows/desktop/ms644931(v=vs.85).aspx public async Task UpgradeOrInstall(IAbsoluteDirectoryPath destination, Settings settings, params IAbsoluteFilePath[] files) { var theShell = GetTheShell(destination, files); if (theShell.Exists) await Uninstall(destination, settings, files).ConfigureAwait(false); await Install(destination, settings, files).ConfigureAwait(false); }
void HandleUserconfig(IAbsoluteDirectoryPath dir) { var userConfigPath = dir.GetChildDirectoryWithName("userconfig"); if (!userConfigPath.Exists) return; System.Console.WriteLine("Found userconfig in {0}, processing", dir); HandleUserConfigPath(dir, userConfigPath); }
public Package Import(Repository repo, IAbsoluteDirectoryPath workDir, IAbsoluteFilePath packageFilePath) { var metaData = Package.Load(packageFilePath); var package = new Package(workDir, metaData, repo); package.Commit(metaData.GetVersionInfo()); return package; }
public async Task StartSession(Uri url, IAbsoluteDirectoryPath destination, CancellationToken cancelToken = new CancellationToken()) { if (Consts.PluginBrowserFound != Browser.None) { Tools.Generic.OpenUrl(url); return; } await StartSessionImpl(url, destination, cancelToken).ConfigureAwait(false); }
public GameInstalledState(IAbsoluteFilePath executable, IAbsoluteDirectoryPath directory, Version version = null) { Contract.Requires<ArgumentNullException>(executable != null); Contract.Requires<ArgumentNullException>(directory != null); Executable = executable; Directory = directory; Version = version; }
static void MigrateServerModFolder(IAbsoluteDirectoryPath modFolder, IAbsoluteDirectoryPath modPath) { var folderName = modFolder.DirectoryName; var destination = modPath.GetChildDirectoryWithName(folderName); if (!destination.Exists) Tools.FileUtil.Ops.MoveDirectory(modFolder, destination); else Directory.Delete(modFolder.ToString(), true); }
public override bool CanGetRelativePathFrom(IAbsoluteDirectoryPath pivotDirectory) { Argument.IsNotNull(nameof(pivotDirectory), pivotDirectory); string pathResultUnused, failureReasonUnused; return AbsoluteRelativePathHelpers.TryGetRelativePath(pivotDirectory, this, out pathResultUnused, out failureReasonUnused); }
public HandleKeyParams(IAbsoluteDirectoryPath keyPath, string prefix, bool copyKey, IAbsoluteDirectoryPath directory, IAbsoluteFilePath key) { KeyPath = keyPath; Prefix = prefix; CopyKey = copyKey; Directory = directory; Key = key; }
void ProcessDirectory(ProcessDirectoryOrFileParams spec, IAbsoluteDirectoryPath directory) { if (spec.OnlyWhenMissing) { ProcessDirectoryOnlyMissing(spec, directory); return; } var biKeyPair = GetKey(spec, directory); _biSigner.SignFolder(directory, biKeyPair.PrivateFile, spec.RepackIfFailed); }
static string GenerateBatContent(IAbsoluteFilePath target, IAbsoluteDirectoryPath workDir, string pars) => String.Format(@" @echo off echo Starting: {0} echo From: {1} echo With params: {2} cd /D ""{1}"" ""{0}"" {2}", target, workDir, pars);
static void WriteUserConfigTar(IAbsoluteDirectoryPath userConfigPath, IAbsoluteDirectoryPath storePath) { storePath.MakeSurePathExists(); //using (var tarFile = new TmpFileCreated()) { Tools.Compression.PackTar(userConfigPath, storePath.GetChildFileWithName("userconfig.tar")); // tarFile.FilePath //Tools.Compression.Gzip.GzipAuto(tarFile.FilePath, storePath.GetChildFileWithName("userconfig.tar.gz")); //} }
bool IsRightVersion(IAbsoluteDirectoryPath rsyncDir, KeyValuePair<string, SixRepoModDto> mod) { var versionFile = rsyncDir.GetChildFileWithName(Repository.VersionFileName); if (!versionFile.Exists) return false; var repoInfo = TryReadRepoFile(versionFile); return (repoInfo != null) && (repoInfo.Guid == mod.Value.Guid) && (repoInfo.Version == mod.Value.Version); }
public override bool CanGetRelativePathFrom(IAbsoluteDirectoryPath pivotDirectory, out string failureMessage) { Argument.IsNotNull(nameof(pivotDirectory), pivotDirectory); string relativePath; return AbsoluteRelativePathHelpers.TryGetRelativePath(pivotDirectory, this, out relativePath, out failureMessage); }
public bool CanGetAbsolutePathFrom(IAbsoluteDirectoryPath path, out string failureMessage) { Argument.IsNotNull(nameof(path), path); string absolutePath; return AbsoluteRelativePathHelpers.TryGetAbsolutePathFrom(path, this, out absolutePath, out failureMessage); }
public static string GetRelativeDirectory(this IAbsoluteDirectoryPath path, IAbsoluteDirectoryPath possibleRoot) { if (path.Equals(possibleRoot) || !path.CanGetRelativePathFrom(possibleRoot) || !path.IsRootedIn(possibleRoot)) return path.ToString(); return path.GetRelativePathFrom(possibleRoot).Join(); }
LocalContent ScanForAddonFolders(IAbsoluteDirectoryPath path) { var dirs = new[] { "addons", "dta", "common", "dll" }; if (dirs.Any(x => !path.GetChildDirectoryWithName(x).IsEmptySafe())) { return(!HasContentAlready(path.DirectoryName) ? new ModLocalContent(path.DirectoryName.ToLower(), _realVirtualityGame.Id, new BasicInstallInfo()) : null); } return(null); }
// // Absolute/Relative pathString conversion // IRelativeFilePath IAbsoluteFilePath.GetRelativePathFrom(IAbsoluteDirectoryPath pivotDirectory) { Debug.Assert(pivotDirectory != null); // Enforced by contract string pathRelative, failureReason; if (!AbsoluteRelativePathHelpers.TryGetRelativePath(pivotDirectory, this, out pathRelative, out failureReason)) { throw new ArgumentException(failureReason); } Debug.Assert(pathRelative != null); Debug.Assert(pathRelative.Length > 0); return(new RelativeFilePath(pathRelative + MiscHelpers.DIR_SEPARATOR_CHAR + FileName)); }
public void CreateZsyncFiles(IAbsoluteDirectoryPath rootDirectory, ZsyncMakeOptions options = ZsyncMakeOptions.Default, params string[] excludes) { foreach (var file in Directory.EnumerateFiles(rootDirectory.ToString(), "*.*", SearchOption.AllDirectories) .Where( x => !x.EndsWith(".zsync", StringComparison.CurrentCultureIgnoreCase)) .Select(x => x.ToAbsoluteFilePath()) .Where(x => !excludes.Contains(x.FileName)) ) { CreateZsyncFile(file, options); } }
public void RunExtractPboWithParameters(IAbsoluteFilePath input, IAbsoluteDirectoryPath output, params string[] parameters) { if (!input.Exists) { throw new IOException("File doesn't exist: " + input); } var startInfo = new ProcessStartInfoBuilder(_extractPboBin, BuildParameters(input.ToString(), output.ToString(), parameters)).Build(); ProcessExitResult(_processManager.LaunchAndGrabTool(startInfo)); }
static void TryMoveDir(IAbsoluteDirectoryPath dir, IAbsoluteDirectoryPath newModsPath) { var newPath = newModsPath.GetChildDirectoryWithName(dir.DirectoryName); try { if (newPath.Exists) { Directory.Delete(newPath.ToString(), true); } } finally { Tools.FileUtil.Ops.MoveDirectory(dir, newPath); } }
// // Absolute/Relative pathString conversion // IAbsoluteFilePath IRelativeFilePath.GetAbsolutePathFrom(IAbsoluteDirectoryPath path) { Debug.Assert(path != null); // Enforced by contracts! string pathAbsolute, failureReason; if (!AbsoluteRelativePathHelpers.TryGetAbsolutePathFrom(path, this, out pathAbsolute, out failureReason)) { throw new ArgumentException(failureReason); } Debug.Assert(pathAbsolute != null); Debug.Assert(pathAbsolute.Length > 0); return((pathAbsolute + MiscHelpers.DIR_SEPARATOR_CHAR + FileName).ToAbsoluteFilePath()); }
public static async Task <BundleManager> GetBundleManager(IAbsoluteDirectoryPath synqPath, IAbsoluteDirectoryPath workPath, IEnumerable <KeyValuePair <Guid, Uri[]> > remotes = null) { var repo = GetRepo(synqPath); if (remotes != null) { await ReplaceRemotes(remotes, repo).ConfigureAwait(false); } return(await GetCM(synqPath, workPath, repo).ConfigureAwait(false)); }
public static void InstallTaskForceRadio(IAbsoluteFilePath fi, IAbsoluteDirectoryPath path, bool force) { if (!InstallTs3Plugin(fi, path, force)) { return; } var di = fi.GetBrotherDirectoryWithName("radio-sounds"); if (di.Exists) { InstallTs3PluginFolder(di, path, force); } }
bool IsRightVersion(IAbsoluteDirectoryPath rsyncDir, KeyValuePair <string, SixRepoModDto> mod) { var versionFile = rsyncDir.GetChildFileWithName(Repository.VersionFileName); if (!versionFile.Exists) { return(false); } var repoInfo = TryReadRepoFile(versionFile); return((repoInfo != null) && (repoInfo.Guid == mod.Value.Guid) && (repoInfo.Version == mod.Value.Version)); }
void CopyDirectoryFiles(IAbsoluteDirectoryPath outputFolder, DirectoryInfo di, bool overwrite = false) { outputFolder.MakeSurePathExists(); foreach (var file in di.EnumerateFiles()) { var dest = outputFolder.GetChildFileWithName(file.Name); if (overwrite || !dest.Exists) { Copy(file.FullName.ToAbsoluteFilePath(), dest); } } }
// // Absolute/Relative pathString conversion // IRelativeDirectoryPath IAbsoluteDirectoryPath.GetRelativePathFrom(IAbsoluteDirectoryPath pivotDirectory) { Debug.Assert(pivotDirectory != null); string pathRelativeString, failureReason; if (!AbsoluteRelativePathHelpers.TryGetRelativePath(pivotDirectory, this, out pathRelativeString, out failureReason)) { throw new ArgumentException(failureReason); } Debug.Assert(pathRelativeString != null); Debug.Assert(pathRelativeString.Length > 0); return(pathRelativeString.ToRelativeDirectoryPath()); }
public void HandlePackageRequirements(IAbsoluteDirectoryPath workPath, Repository repository) { HandlePathRequirements(workPath, repository); if (repository.Config.OperationMode == RepositoryOperationMode.SinglePackage) { ConfirmSinglePackagePath(workPath, repository); } else { ConfirmMultiPackagePath(workPath, repository); } }
bool TryInstallPlugin(IAbsoluteDirectoryPath gamePath, IContentEngineContent mod, string plugin, bool force) { try { return(InstallPlugin(gamePath, mod, plugin, force)); } catch (PathDoesntExistException e) { MainLog.Logger.FormattedWarnException(e, "Path: " + e.Path); } catch (Win32Exception e) { MainLog.Logger.FormattedWarnException(e); } catch (Exception ex) { MainLog.Logger.FormattedErrorException(ex); } return(false); }
public FolderInfo(IAbsoluteDirectoryPath path, ContentInfo contentInfo) { if (path == null) { throw new ArgumentNullException(nameof(path)); } if (contentInfo == null) { throw new ArgumentNullException(nameof(contentInfo)); } Path = path; ContentInfo = contentInfo; }
async Task DownloadFilesAsync(StatusRepo sr, IDictionary <FileFetchInfo, ITransferStatus> transferStatuses, IAbsoluteDirectoryPath destinationPath, IMirrorSelector scoreMirrorSelector) { destinationPath.MakeSurePathExists(); sr.Total = transferStatuses.Count; using (var multiMirrorFileDownloader = _createMultiMirrorFileDownloader(scoreMirrorSelector)) using (var multi = _createQueueDownloader(multiMirrorFileDownloader.Value)) { await multi.Value .DownloadAsync(CreateFileQueueSpec(transferStatuses, destinationPath), sr.CancelToken) .ConfigureAwait(false); } }
public void CreateZip(IAbsoluteDirectoryPath directory, IAbsoluteFilePath outputFile) { using (var arc = ZipArchive.Create()) { foreach (var f in directory.DirectoryInfo.EnumerateFiles("*", SearchOption.AllDirectories)) { arc.AddEntry(f.FullName.Replace(directory.ParentDirectoryPath + @"\", ""), f.FullName); } arc.SaveTo(outputFile.ToString(), new ZipWriterOptions(CompressionType.Deflate) { DeflateCompressionLevel = CompressionLevel.BestCompression }); } }
public void Test_Drive() { IAbsoluteDirectoryPath absoluteDirectoryPath = @"C:\Dir1".ToAbsoluteDirectoryPath(); Assert.IsTrue(absoluteDirectoryPath.DriveLetter.ToString() == "C"); absoluteDirectoryPath = @"c:\Dir1".ToAbsoluteDirectoryPath(); Assert.IsTrue(absoluteDirectoryPath.DriveLetter.ToString() == "c"); IAbsoluteFilePath absoluteFilePath = @"C:\Dir1\File.txt".ToAbsoluteFilePath(); Assert.IsTrue(absoluteFilePath.DriveLetter.ToString() == "C"); absoluteFilePath = @"c:\Dir1\File.txt".ToAbsoluteFilePath(); Assert.IsTrue(absoluteFilePath.DriveLetter.ToString() == "c"); }
public IAbsoluteDirectoryPath FindParentWithName(IAbsoluteDirectoryPath path, string key) { var parent = path; while (parent.HasParentDirectory) { parent = parent.ParentDirectoryPath; if (parent.DirectoryName.Equals(key, StringComparison.OrdinalIgnoreCase)) { return(parent); } } return(null); }
void TryUserconfigDirectory(IAbsoluteDirectoryPath path, IAbsoluteDirectoryPath uconfigPath) { try { Tools.FileUtil.Ops.CopyDirectoryWithUpdaterFallbackAndRetry(path, uconfigPath); } catch (Win32Exception ex) { if (ex.NativeErrorCode != Win32ErrorCodes.ERROR_CANCELLED_ELEVATION) { throw; } throw ex.HandleUserCancelled(); } catch (IOException e) { this.Logger().FormattedWarnException(e); } }
public void MoveDirectory(IAbsoluteDirectoryPath sourcePath, IAbsoluteDirectoryPath destinationPath) { if (IsSameRoot(sourcePath, destinationPath)) { var tmp = destinationPath + GenericTools.TmpExtension; Directory.Move(sourcePath.ToString(), tmp); Directory.Move(tmp, destinationPath.ToString()); } else { CopyDirectoryWithRetry(sourcePath, destinationPath, true); Directory.Delete(sourcePath.ToString(), true); } }
public ContentPaths(IAbsoluteDirectoryPath path, IAbsoluteDirectoryPath repositoryPath) { if (path == null) { throw new ArgumentNullException(nameof(path)); } if (repositoryPath == null) { throw new ArgumentNullException(nameof(repositoryPath)); } Path = path; RepositoryPath = repositoryPath; }
void TryUserconfigDirectory(IAbsoluteDirectoryPath path, IAbsoluteDirectoryPath uconfigPath) { try { Tools.FileUtil.Ops.CopyDirectoryWithUpdaterFallbackAndRetry(path, uconfigPath); } catch (Win32Exception ex) { if (ex.IsElevationCancelled()) { throw ex.HandleUserCancelled(); } throw; } catch (IOException e) { this.Logger().FormattedWarnException(e); } }
public void Test_GetRelativePathWithError3() { IAbsoluteDirectoryPath absoluteDirectoryPathTo = @"C:\Dir1".ToAbsoluteDirectoryPath(); IAbsoluteDirectoryPath absoluteDirectoryPathFrom = @"D:\Dir1".ToAbsoluteDirectoryPath(); Assert.IsFalse(absoluteDirectoryPathTo.CanGetRelativePathFrom(absoluteDirectoryPathFrom)); string failureReason; Assert.IsFalse(absoluteDirectoryPathTo.CanGetRelativePathFrom(absoluteDirectoryPathFrom, out failureReason)); Assert.IsTrue(failureReason == @"Cannot compute relative path from 2 paths that are not on the same volume PathFrom = ""D:\Dir1"" PathTo = ""C:\Dir1"""); Assert.Throws(typeof(ArgumentException), delegate { absoluteDirectoryPathTo.GetRelativePathFrom(absoluteDirectoryPathFrom); }); }
IEnumerable <IAbsolutePath> TryGetModFolders(IAbsoluteDirectoryPath modPath) { var di = new DirectoryInfo(modPath.ToString()); if (!di.Exists) { return(Enumerable.Empty <IAbsolutePath>()); } return(Enumerable.Repeat(di, 1).Concat(di.RecurseFilterDottedDirectories()) .Select(x => x.FullName) .Where(modPathValidator.Validate) .Select(x => x.ToAbsoluteDirectoryPath())); }
public SULaunchGameSteamArgumentsBuilder(LaunchGameWithSteamInfo spec, IAbsoluteDirectoryPath steamPath) : base(spec) { if (steamPath == null) { throw new ArgumentNullException(nameof(steamPath)); } if (!(spec.SteamAppId > 0)) { throw new ArgumentNullException("spec.SteamAppId > 0"); } _steamPath = steamPath; _spec = spec; }
public void Test_GetAbsolutePathPathWithError3() { IRelativeFilePath directoryPathTo = @"..\..\Dir1\File.txt".ToRelativeFilePath(); IAbsoluteDirectoryPath absoluteDirectoryPathFrom = @"C:\Dir1".ToAbsoluteDirectoryPath(); Assert.IsFalse(directoryPathTo.CanGetAbsolutePathFrom(absoluteDirectoryPathFrom)); string failureReason; Assert.IsFalse(directoryPathTo.CanGetAbsolutePathFrom(absoluteDirectoryPathFrom, out failureReason)); Assert.IsTrue(failureReason == @"Cannot resolve pathTo.TryGetAbsolutePath(pathFrom) because there are too many parent dirs in pathTo: PathFrom = ""C:\Dir1"" PathTo = ""..\..\Dir1"""); directoryPathTo.GetAbsolutePathFrom(absoluteDirectoryPathFrom); }
public void Test_GetRelativePathWithError3() { IAbsoluteFilePath filePathTo = @"C:\Dir1\File.txt".ToAbsoluteFilePath(); IAbsoluteDirectoryPath absoluteDirectoryPathFrom = @"D:\Dir1".ToAbsoluteDirectoryPath(); Assert.IsFalse(filePathTo.CanGetRelativePathFrom(absoluteDirectoryPathFrom)); string failureReason; Assert.IsFalse(filePathTo.CanGetRelativePathFrom(absoluteDirectoryPathFrom, out failureReason)); Assert.IsTrue(failureReason == @"Cannot compute relative path from 2 paths that are not on the same volume PathFrom = ""D:\Dir1"" PathTo = ""C:\Dir1\File.txt"""); filePathTo.GetRelativePathFrom(absoluteDirectoryPathFrom); }
static void MigrateServerModFolder(IAbsoluteDirectoryPath modFolder, IAbsoluteDirectoryPath modPath) { var folderName = modFolder.DirectoryName; var destination = modPath.GetChildDirectoryWithName(folderName); if (!destination.Exists) { Tools.FileUtil.Ops.MoveDirectory(modFolder, destination); } else { Directory.Delete(modFolder.ToString(), true); } }
public void Test_PathEquality() { // // RelativeDirectoryPath // IRelativeDirectoryPath relativeRelativeDirectoryPath1 = @"..\Dir1\Dir2".ToRelativeDirectoryPath(); IRelativeDirectoryPath relativeRelativeDirectoryPath2 = @"..\\dir1//DIR2/".ToRelativeDirectoryPath(); Assert.IsTrue(relativeRelativeDirectoryPath1.Equals(relativeRelativeDirectoryPath2)); relativeRelativeDirectoryPath1 = @"..\Dir1\Dir2".ToRelativeDirectoryPath(); relativeRelativeDirectoryPath2 = @".\Dir1\Dir2".ToRelativeDirectoryPath(); Assert.IsFalse(relativeRelativeDirectoryPath1.Equals(relativeRelativeDirectoryPath2)); relativeRelativeDirectoryPath1 = @"..\Dir1\Dir2".ToRelativeDirectoryPath(); relativeRelativeDirectoryPath2 = @"..\Dir1\Dir2\Dir3".ToRelativeDirectoryPath(); Assert.IsFalse(relativeRelativeDirectoryPath1.Equals(relativeRelativeDirectoryPath2)); relativeRelativeDirectoryPath1 = @"..\Dir1\Dir2".ToRelativeDirectoryPath(); relativeRelativeDirectoryPath2 = @"..\Dir1\Dir".ToRelativeDirectoryPath(); Assert.IsFalse(relativeRelativeDirectoryPath1.Equals(relativeRelativeDirectoryPath2)); // // AbsoluteDirectoryPath // IAbsoluteDirectoryPath absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath(); IAbsoluteDirectoryPath absoluteAbsoluteDirectoryPath2 = @"C:\\dir1//Dir2\\".ToAbsoluteDirectoryPath(); Assert.IsTrue(absoluteAbsoluteDirectoryPath1.Equals(absoluteAbsoluteDirectoryPath2)); absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath(); absoluteAbsoluteDirectoryPath2 = @"D:\Dir1\Dir2".ToAbsoluteDirectoryPath(); Assert.IsFalse(absoluteAbsoluteDirectoryPath1.Equals(absoluteAbsoluteDirectoryPath2)); absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath(); absoluteAbsoluteDirectoryPath2 = @"C:\Dir1\Dir2\Dir2".ToAbsoluteDirectoryPath(); Assert.IsFalse(absoluteAbsoluteDirectoryPath1.Equals(absoluteAbsoluteDirectoryPath2)); absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath(); absoluteAbsoluteDirectoryPath2 = @"C:\Dir1\Dir".ToAbsoluteDirectoryPath(); Assert.IsFalse(absoluteAbsoluteDirectoryPath1.Equals(absoluteAbsoluteDirectoryPath2)); // // Mix between AbsoluteDirectoryPath and RelativeDirectoryPath // relativeRelativeDirectoryPath1 = @"..\Dir1\Dir2".ToRelativeDirectoryPath(); absoluteAbsoluteDirectoryPath1 = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath(); Assert.IsFalse(absoluteAbsoluteDirectoryPath1.Equals(relativeRelativeDirectoryPath1)); }
// // Path resolving // public EnvironmentVariableResolvingStatus TryResolve(out IAbsoluteDirectoryPath resolvedPath) { resolvedPath = null; string pathStringResolved; if (!TryResolveEnvVar(out pathStringResolved)) { return EnvironmentVariableResolvingStatus.UnresolvedEnvironmentVariable; } if (!pathStringResolved.IsValidAbsoluteDirectoryPath()) { return EnvironmentVariableResolvingStatus.CannotConvertToAbsolutePath; } resolvedPath = pathStringResolved.ToAbsoluteDirectoryPath(); return EnvironmentVariableResolvingStatus.Success; }