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 Repository Init(IAbsoluteDirectoryPath directory, RepositoryOperationMode?mode = null) { if (directory == null) { throw new ArgumentNullException(nameof(directory)); } if (File.Exists(directory.ToString())) { throw new SynqPathException("Already exists file with same name"); } ConfirmEmpty(directory); directory.MakeSurePathExists(); var repo = new Repository(directory, true); try { if (mode != null) { repo.Config.OperationMode = mode.Value; } repo.Save(); } catch { repo.Dispose(); throw; } return(repo); }
public async Task Install(bool force) { _destination.MakeSurePathExists(); var pakFile = _destination.GetChildFileWithName(GetPakName()); if (!force && pakFile.Exists) // TODO: Date check { return; } if (!_source.Exists) { throw new NotFoundException($"{_mod.PackageName} source not found! You might try Diagnosing"); } foreach (var c in _source.DirectoryInfo.EnumerateFiles("*") .Where(x => NDependPathHelpers.ArchiveRx.IsMatch(x.Extension)) .Select(x => x.ToAbsoluteFilePath())) { c.Unpack(_source, true); } var modInfo = EnumerateMatchingFiles("modinfo.xml").FirstOrDefault(); if ((modInfo != null) && modInfo.Exists) { await HandleAsModInfoBasedMod(modInfo).ConfigureAwait(false); } else { await HandleFileBasedMod(pakFile).ConfigureAwait(false); } }
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 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 void BackupScriptHook() { _gameLocalDataFolder.MakeSurePathExists(); foreach (var f in scriptHookFiles) { _state.Directory.GetChildFileWithName(f).Copy(_gameLocalDataFolder.GetChildFileWithName(f)); } }
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")); //} }
public void MoveModFolders(IAbsoluteDirectoryPath oldModsPath, IAbsoluteDirectoryPath newModsPath) { newModsPath.MakeSurePathExists(); foreach (var dir in Directory.EnumerateDirectories(oldModsPath.ToString()) .Where(x => !excludeFolders.Contains(Path.GetFileName(x).ToLower())) .Where(x => File.Exists(Path.Combine(x, Package.SynqInfoFile)) || Directory.Exists(Path.Combine(x, Repository.RepoFolderName)))) TryMoveDir(dir.ToAbsoluteDirectoryPath(), newModsPath); }
public async Task Install() { _installPath.MakeSurePathExists(); foreach (var f in _sourceDir.DirectoryInfo.EnumerateFiles()) { await f.ToAbsoluteFilePath().CopyAsync(_installPath).ConfigureAwait(false); } }
protected override async Task InstallImpl(bool force) { _installPath.MakeSurePathExists(); foreach (var f in SourcePath.DirectoryInfo.EnumerateFiles()) { await f.ToAbsoluteFilePath().CopyAsync(_installPath).ConfigureAwait(false); } }
public async Task Install(IAbsoluteDirectoryPath destination, Settings settings, params IAbsoluteFilePath[] files) { destination.MakeSurePathExists(); foreach (var f in files) await f.CopyAsync(destination).ConfigureAwait(false); var theShell = GetTheShell(destination, files); RunSrm(theShell, "install", "-codebase"); await RestartExplorer().ConfigureAwait(false); settings.ExtensionInstalled(); }
static void UnpackArchive(IAbsoluteFilePath sourceFile, IAbsoluteDirectoryPath outputFolder, bool overwrite, bool checkFileIntegrity, SevenZipExtractor extracter) { if (checkFileIntegrity && !extracter.Check()) throw new Exception(String.Format("Appears to be an invalid archive: {0}", sourceFile)); outputFolder.MakeSurePathExists(); extracter.ExtractFiles(outputFolder.ToString(), overwrite ? extracter.ArchiveFileNames.ToArray() : extracter.ArchiveFileNames.Where(x => !outputFolder.GetChildFileWithName(x).Exists) .ToArray()); }
async Task DownloadFileAsync(string remoteFile, IAbsoluteDirectoryPath destinationPath, IMirrorSelector scoreMirrorSelector, CancellationToken token) { destinationPath.MakeSurePathExists(); using (var dl = _createMultiMirrorFileDownloader(scoreMirrorSelector)) { await dl.Value.DownloadAsync(new MultiMirrorFileDownloadSpec(remoteFile, destinationPath.GetChildFileWithName(remoteFile)) { CancellationToken = token }, token) .ConfigureAwait(false); } }
public void MoveModFolders(IAbsoluteDirectoryPath oldModsPath, IAbsoluteDirectoryPath newModsPath) { newModsPath.MakeSurePathExists(); foreach (var dir in Directory.EnumerateDirectories(oldModsPath.ToString()) .Where(x => !excludeFolders.Contains(Path.GetFileName(x).ToLower())) .Where(x => File.Exists(Path.Combine(x, Package.SynqInfoFile)) || Directory.Exists(Path.Combine(x, Repository.RepoFolderName)))) { TryMoveDir(dir.ToAbsoluteDirectoryPath(), newModsPath); } }
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); } }
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); } } }
protected override async Task InstallImpl(bool force) { _modDir.MakeSurePathExists(); var exts = new[] { ".pak", ".modpak" }; var destPakFile = _modDir.GetChildFileWithName($"{Mod.PackageName}.pak"); if (!force && destPakFile.Exists) // TODO: Date check { return; } // TODO: Support mods without Paks, as folder ? Or mark as not-installable var sourcePakFiles = exts.SelectMany(x => SourcePath.DirectoryInfo.EnumerateFiles($"*{x}", SearchOption.AllDirectories)) .Select(x => x.ToAbsoluteFilePath()).ToArray(); var sourcePak = sourcePakFiles.FirstOrDefault(); IAbsoluteFilePath sourcePakPath; if ((sourcePak == null) || !sourcePak.Exists) { var modInfo = SourcePath.DirectoryInfo.EnumerateFiles("*.modinfo", SearchOption.AllDirectories) .FirstOrDefault(); if (modInfo != null) { sourcePakPath = await PackModInfoMod(modInfo.ToAbsoluteFilePath()).ConfigureAwait(false); } else { var metadata = SourcePath.DirectoryInfo.EnumerateFiles(".metadata", SearchOption.AllDirectories) .FirstOrDefault(); if (metadata == null) { throw new NotInstallableException( $"{Mod.PackageName} source .pak not found! You might try Diagnosing"); } sourcePakPath = await PackMetadataMod(metadata.ToAbsoluteFilePath()).ConfigureAwait(false); } } else { sourcePakPath = sourcePak; } await sourcePakPath.CopyAsync(destPakFile).ConfigureAwait(false); var bak = GetBackupFile(destPakFile); bak.DeleteIfExists(); }
public Repository Init(IAbsoluteDirectoryPath directory, RepositoryOperationMode? mode = null) { Contract.Requires<ArgumentNullException>(directory != null); if (File.Exists(directory.ToString())) throw new SynqPathException("Already exists file with same name"); ConfirmEmpty(directory); directory.MakeSurePathExists(); var repo = new Repository(directory, true); if (mode != null) repo.Config.OperationMode = mode.Value; repo.Save(); return repo; }
void ExtractFolder(IAbsoluteDirectoryPath rootPath, IAbsoluteDirectoryPath tempPath, IAbsoluteDirectoryPath destination, IStatus status) { destination = destination.GetChildDirectoryWithName("addons"); destination.MakeSurePathExists(); var files = Directory.GetFiles(Path.Combine(rootPath.ToString(), "addons"), "*.ifa"); var i = 0; foreach (var f in files) { ProcessPbo(f, tempPath, destination); i++; status.Update(null, (double)i / files.Length * 100); } }
public async Task Install(IAbsoluteDirectoryPath destination, Settings settings, params IAbsoluteFilePath[] files) { destination.MakeSurePathExists(); foreach (var f in files) { await f.CopyAsync(destination).ConfigureAwait(false); } var theShell = GetTheShell(destination, files); RunSrm(theShell, "install", "-codebase"); await RestartExplorer().ConfigureAwait(false); settings.ExtensionInstalled(); }
public void CopyDirectoryWithRetry(IAbsoluteDirectoryPath sourceFolder, IAbsoluteDirectoryPath outputFolder, bool overwrite = false) { var di = sourceFolder.DirectoryInfo; outputFolder.MakeSurePathExists(); CopyDirectoryFilesWithRetry(outputFolder, di, overwrite); foreach (var directory in di.EnumerateDirectories("*.*", SearchOption.AllDirectories)) { CopyDirectoryFilesWithRetry( outputFolder.GetChildDirectoryWithName(directory.FullName.Replace(sourceFolder + "\\", string.Empty)), directory, overwrite); } }
public PackageManager(Repository repo, IAbsoluteDirectoryPath workDir, StatusRepo statusRepo, bool createWhenNotExisting = false, string remote = null) { if (repo == null) { throw new ArgumentNullException(nameof(repo)); } if (workDir == null) { throw new ArgumentNullException(nameof(workDir)); } WorkDir = workDir; StatusRepo = statusRepo; Repo = repo; 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; }
protected override async Task InstallImpl(bool force) { var modName = GetModName(); _modPath.MakeSurePathExists(); var destinationDir = _modPath.GetChildDirectoryWithName(modName); if (destinationDir.Exists) { destinationDir.Delete(true); } SourceZip.Unpack(destinationDir, true); var desc = destinationDir.GetChildFileWithName("descriptor.mod"); var modFile = _modPath.GetChildFileWithName($"{modName}.mod"); modFile.WriteText( desc.ReadAllText() .Replace($"archive=\"{modName}.zip\"", $"path=\"{GetRelModName()}\"")); }
public TmpDirectory(IAbsoluteDirectoryPath path) { path.MakeSurePathExists(); _path = path; }
public TmpDirectory(IAbsoluteDirectoryPath path) { path.MakeSurePathExists(); _path = path; }
void ExtractFolder(IAbsoluteDirectoryPath rootPath, IAbsoluteDirectoryPath tempPath, IAbsoluteDirectoryPath destination, IStatus status) { destination = destination.GetChildDirectoryWithName("addons"); destination.MakeSurePathExists(); var files = Directory.GetFiles(Path.Combine(rootPath.ToString(), "addons"), "*.ifa"); var i = 0; foreach (var f in files) { ProcessPbo(f, tempPath, destination); i++; status.Update(null, ((double)i / files.Length) * 100); } }
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); } }
async Task DownloadFileAsync(string remoteFile, IAbsoluteDirectoryPath destinationPath, ExportLifetimeContext<IMirrorSelector> scoreMirrorSelector, CancellationToken token) { destinationPath.MakeSurePathExists(); using (var dl = _createMultiMirrorFileDownloader(scoreMirrorSelector.Value)) { await dl.Value.DownloadAsync(new MultiMirrorFileDownloadSpec(remoteFile, destinationPath.GetChildFileWithName(remoteFile)) {CancellationToken = token}, token) .ConfigureAwait(false); } }
async Task DownloadFilesAsync(StatusRepo sr, IDictionary<KeyValuePair<string, Func<IAbsoluteFilePath, bool>>, ITransferStatus> transferStatuses, IAbsoluteDirectoryPath destinationPath, ExportLifetimeContext<IMirrorSelector> scoreMirrorSelector) { destinationPath.MakeSurePathExists(); sr.Total = transferStatuses.Count; using (var multiMirrorFileDownloader = _createMultiMirrorFileDownloader(scoreMirrorSelector.Value)) using (var multi = _createQueueDownloader(multiMirrorFileDownloader.Value)) { await multi.Value .DownloadAsync(CreateFileQueueSpec(transferStatuses, destinationPath), sr.CancelToken) .ConfigureAwait(false); } }
async Task DownloadFileAsync(string remoteFile, IAbsoluteDirectoryPath destinationPath, ExportLifetimeContext<IMirrorSelector> scoreMirrorSelector, CancellationToken token, Func<IAbsoluteFilePath, bool> confirmValidity, int zsyncHttpFallbackAfter) { destinationPath.MakeSurePathExists(); using (var dl = _createMultiMirrorFileDownloader(scoreMirrorSelector.Value)) { await dl.Value.DownloadAsync(new MultiMirrorFileDownloadSpec(remoteFile, destinationPath.GetChildFileWithName(remoteFile), confirmValidity) { CancellationToken = token, Progress = new TransferStatus(remoteFile) {ZsyncHttpFallbackAfter = zsyncHttpFallbackAfter} }, token).ConfigureAwait(false); } }