Exemple #1
0
        private void ZSyncMake()
        {
            Console.WriteLine("generating zsync control files");
            var zsync = new ZSyncMake(_tools.GetChildFileWithName("zsyncmake.exe").ToString());

            zsync.Make(_folder.ToString());
        }
Exemple #2
0
            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);
                }
            }
Exemple #3
0
 public void BackupScriptHook()
 {
     _gameLocalDataFolder.MakeSurePathExists();
     foreach (var f in scriptHookFiles)
     {
         _state.Directory.GetChildFileWithName(f).Copy(_gameLocalDataFolder.GetChildFileWithName(f));
     }
 }
Exemple #4
0
        void SetSixSyncPaths()
        {
            var path = Path;

            _repoPath           = path == null ? null : path.GetChildDirectoryWithName(Repository.RepoFolderName);
            _repoYamlFile       = _repoPath == null ? null : _repoPath.GetChildFileWithName(Repository.VersionFileName);
            _repoConfigYamlFile = _repoPath == null
                ? null
                : _repoPath.GetChildFileWithName(Repository.ConfigFileName);
        }
Exemple #5
0
            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();
            }
        protected static async Task BuildAndRunBatFile(IProcessManager pm, IAbsoluteDirectoryPath tmpFolder,
                                                       IEnumerable <string> commands, bool asAdministrator = false, bool noisy = false)
        {
            var batFile        = tmpFolder.GetChildFileWithName("install.bat");
            var actualCommands =
                new[] { "chcp 65001" }.Concat(commands)
            .Concat(new[] { "echo finished" })
            .Select(x => x == "" ? x : x + " >> install.log");
            var commandBat = string.Join("\r\n",
                                         new[] { "", "echo starting > install.log" }.Concat(actualCommands)
                                         .Concat(new[] { "" }));
            var encoding = Encoding.UTF8;

            File.WriteAllText(batFile.ToString(), commandBat, encoding);
            if (Common.Flags.Verbose || noisy)
            {
                MainLog.Logger.Info("install.bat content:\n" + commandBat);
            }

            try {
                var pInfo = new ProcessStartInfoBuilder(batFile)
                {
                    WorkingDirectory = tmpFolder
                                       //WindowStyle = ProcessWindowStyle.Minimized
                }.Build();
                pInfo.CreateNoWindow = true;
                var basicLaunchInfo = new BasicLaunchInfo(pInfo)
                {
                    StartMinimized = true
                };
                var r =
                    await(asAdministrator ? pm.LaunchElevatedAsync(basicLaunchInfo) : pm.LaunchAsync(basicLaunchInfo));
                r.ConfirmSuccess();
            } catch (Win32Exception ex) {
                if (ex.IsElevationCancelled())
                {
                    throw ex.HandleUserCancelled();
                }
                throw;
            }
            var logFile = tmpFolder.GetChildFileWithName("install.log");
            var output  = File.ReadAllText(logFile.ToString(), encoding);

            if (Common.Flags.Verbose || noisy)
            {
                MainLog.Logger.Info("install.bat output:\n" + output);
            }
        }
        private void UnpackArchive(IAbsoluteDirectoryPath outputFolder, bool overwrite, IArchive archive,
                                   ExtractionOptions options, IAbsoluteFilePath sourceFile)
        {
            foreach (var p in archive.Entries.Where(entry => entry.IsDirectory)
                     .Select(entry => outputFolder.GetChildDirectoryWithName(entry.Key)))
            {
                p.MakeSurePathExists();
            }

            foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
            {
                var fileName        = entry.Key ?? sourceFile.FileNameWithoutExtension;
                var destinationFile = outputFolder.GetChildFileWithName(fileName);
                if (overwrite)
                {
                    destinationFile.MakeSureParentPathExists();
                    entry.WriteToFile(destinationFile.ToString(), options);
                }
                else
                {
                    if (destinationFile.Exists)
                    {
                        continue;
                    }
                    destinationFile.MakeSureParentPathExists();
                    entry.WriteToFile(destinationFile.ToString(), options);
                }
            }
        }
Exemple #8
0
        protected static IAbsoluteFilePath GetExe(IAbsoluteDirectoryPath gameExePath,
                                                  SeparateClientAndServerExecutable executables, bool forceServer)
        {
            var executable       = gameExePath.GetChildFileWithName(executables.Client);
            var serverExecutable = gameExePath.GetChildFileWithName(executables.Server);

            if (forceServer)
            {
                return(serverExecutable);
            }
            if (!executable.Exists && serverExecutable.Exists)
            {
                return(serverExecutable);
            }
            return(executable);
        }
        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();
                        }
                    }
                }
            }
        }
Exemple #10
0
        public async Task UploadMission(RequestMissionUploadModel model, IAbsoluteDirectoryPath path)
        {
            if (model == null)
            {
                throw new ArgumentNullException(nameof(model));
            }
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            ValidateObject(model);
            ConfirmConnected();
            var uploadRequest = await _connectionManager.MissionsHub.RequestMissionUpload(model).ConfigureAwait(false);

            await UploadFileToAWS(path.GetChildFileWithName(model.FileName), uploadRequest).ConfigureAwait(false);

            var uploadedModel = new MissionUploadedModel {
                GameSlug  = model.GameSlug,
                Name      = model.Name,
                UploadKey = uploadRequest.Key
            };

            ValidateObject(uploadedModel);
            await _connectionManager.MissionsHub.MissionUploadCompleted(uploadedModel).ConfigureAwait(false);
        }
Exemple #11
0
        static bool InstallDll(IAbsoluteFilePath fi, IAbsoluteDirectoryPath destination, string subPath = null,
                               bool force = true)
        {
            if (destination == null)
            {
                throw new ArgumentNullException(nameof(destination));
            }

            if (!destination.Exists)
            {
                throw new PathDoesntExistException(destination.ToString());
            }
            if (subPath != null)
            {
                destination = destination.GetChildDirectoryWithName(subPath);
            }
            var fullPath = destination.GetChildFileWithName(fi.FileName);

            if (!force && fullPath.Exists)
            {
                return(false);
            }

            return(TryCopyDll(fi, fullPath));
        }
Exemple #12
0
        static bool InstallDll(IAbsoluteFilePath pluginPath, IAbsoluteDirectoryPath gamePluginFolder,
                               bool force = true)
        {
            if (gamePluginFolder == null)
            {
                throw new ArgumentNullException(nameof(gamePluginFolder));
            }
            if (pluginPath == null)
            {
                throw new ArgumentNullException(nameof(pluginPath));
            }

            if (!pluginPath.IsNotNullAndExists())
            {
                throw new PathDoesntExistException(pluginPath.ToString());
            }

            if (!gamePluginFolder.IsNotNullAndExists())
            {
                throw new PathDoesntExistException(gamePluginFolder.ToString());
            }

            var fullPath = gamePluginFolder.GetChildFileWithName(pluginPath.FileName);

            if (!force && fullPath.Exists)
            {
                return(false);
            }

            return(TryCopyDll(pluginPath, fullPath));
        }
Exemple #13
0
        public static async Task <SynqSpec> ReadSynqSpecAsync(IAbsoluteDirectoryPath path)
        {
            var specFile = path.GetChildFileWithName(SynqSpecFile);

            return(specFile.Exists
                ? await Tools.Serialization.Json.LoadJsonFromFileAsync <SynqSpec>(specFile).ConfigureAwait(false)
                : new SynqSpec());
        }
Exemple #14
0
 public SteamLauncher(IAbsoluteDirectoryPath steamPath)
 {
     SteamPath = steamPath;
     if (steamPath != null)
     {
         SteamExePath = steamPath.GetChildFileWithName(SteamInfos.SteamExecutable);
     }
 }
        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 InstallOfficialPatchInternal(string patchFile, IAbsoluteDirectoryPath tempPath, ITransferStatus status)
        {
            var filePath = tempPath.GetChildFileWithName(patchFile);

            Download(patchFile, status, filePath);
            status.Reset();
            InstallPatch(filePath, "-silent");
        }
 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"));
     //}
 }
 protected static void ExtractFile(IAbsoluteDirectoryPath tmpFolder, string fileName) {
     var destinationFile = tmpFolder.GetChildFileWithName(fileName);
     using (var s = GetApiStream(fileName))
     using (
         var f = new FileStream(destinationFile.ToString(), FileMode.Create, FileAccess.ReadWrite, FileShare.None)
     )
         s.CopyTo(f);
 }
            private async Task <bool> ShouldInstall(IProcessManager pm, IAbsoluteDirectoryPath toolLocation,
                                                    IAbsoluteDirectoryPath tmpFolder, IAbsoluteDirectoryPath p)
            {
                await RunCertCommands(pm, toolLocation, tmpFolder, BuildCheckCommand(toolLocation, p));

                return
                    (!File.ReadAllText(tmpFolder.GetChildFileWithName("install.log").ToString())
                     .Contains("FC:A9:28:2C:0C:D0:39:4F:61:42:9B:BB:FD:B5:9B:AC:FC:73:38:C9"));
            }
Exemple #20
0
 void RestoreFileFromBackup(IAbsoluteDirectoryPath backupDir, string fileName) {
     var existingFile = InstalledState.Directory.GetChildFileWithName(fileName);
     if (existingFile.Exists)
         return;
     var backupFile = backupDir.GetChildFileWithName(fileName);
     if (!backupFile.Exists)
         return;
     backupFile.Copy(existingFile);
 }
            private async Task InstallCerts(IProcessManager pm, IAbsoluteDirectoryPath toolLocation,
                                            IAbsoluteDirectoryPath tmpFolder, IEnumerable <IAbsoluteDirectoryPath> todoProfiles,
                                            string certFileName)
            {
                ExtractFile(tmpFolder, certFileName);
                var certFile = tmpFolder.GetChildFileWithName(certFileName);

                await RunCertCommands(pm, toolLocation, tmpFolder, todoProfiles.Select(p => BuildInstallCommand(toolLocation, certFile, p)).ToArray()).ConfigureAwait(false);
            }
Exemple #22
0
        public static SpecificVersion ReadSynqInfoFile(IAbsoluteDirectoryPath packageDir)
        {
            if (!packageDir.Exists)
            {
                return(null);
            }
            var file = packageDir.GetChildFileWithName(SynqInfoFile);

            return(!file.Exists ? null : new SpecificVersion(File.ReadAllText(file.ToString())));
        }
        protected static void ExtractFile(IAbsoluteDirectoryPath tmpFolder, string fileName)
        {
            var destinationFile = tmpFolder.GetChildFileWithName(fileName);

            using (var s = GetApiStream(fileName))
                using (
                    var f = new FileStream(destinationFile.ToString(), FileMode.Create, FileAccess.ReadWrite, FileShare.None)
                    )
                    s.CopyTo(f);
        }
 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);
     }
 }
Exemple #25
0
 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());
 }
Exemple #26
0
            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()}\""));
            }
Exemple #27
0
        public override int Run(string[] remainingArguments)
        {
            var cf = new MainControlFile()
            {
                Content = ListAllItems().ToList()
            };

            Console.WriteLine($"Generated zsync controls for {cf.Content.Count} files");
            File.WriteAllText(_folder.GetChildFileWithName(".zsync-control.jar").ToString(), JsonConvert.SerializeObject(cf, Formatting.Indented));
            return(0);
        }
        public void Test_GetChildWithName()
        {
            IAbsoluteDirectoryPath absoluteDirectoryPath = @"C:\Dir1\Dir2".ToAbsoluteDirectoryPath();

            Assert.IsTrue(absoluteDirectoryPath.GetChildFileWithName("File.txt").ToString() == @"C:\Dir1\Dir2\File.txt");
            Assert.IsTrue(absoluteDirectoryPath.GetChildDirectoryWithName("Dir3").ToString() == @"C:\Dir1\Dir2\Dir3");

            IRelativeDirectoryPath relativeDirectoryPath = @"..\..\Dir1\Dir2".ToRelativeDirectoryPath();

            Assert.IsTrue(relativeDirectoryPath.GetChildFileWithName("File.txt").ToString() == @"..\..\Dir1\Dir2\File.txt");
            Assert.IsTrue(relativeDirectoryPath.GetChildDirectoryWithName("Dir3").ToString() == @"..\..\Dir1\Dir2\Dir3");
        }
Exemple #29
0
                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);
                        }
                    }
                }
Exemple #30
0
        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));
        }
Exemple #31
0
        private static IEnumerable <IAbsoluteFilePath> FindAllConventionFiles(IAppEnvironment appEnvironment)
        {
            var conventionFilePaths = new List <IAbsoluteFilePath>();

            foreach (IAbsoluteDirectoryPath pluginPath in appEnvironment.TemplatesPath.ChildrenDirectoriesPath)
            {
                foreach (IAbsoluteDirectoryPath child in pluginPath.ChildrenDirectoriesPath)
                {
                    IAbsoluteDirectoryPath current = child;

                    while (current != null)
                    {
                        if (current.GetChildFileWithName("conventions.json").Exists)
                        {
                            conventionFilePaths.Add(current.GetChildFileWithName("conventions.json"));
                        }

                        current = current.ChildrenDirectoriesPath.FirstOrDefault();
                    }
                }
            }

            return(conventionFilePaths);
        }
 private static IReadOnlyCollection<IRelativeFilePath> GetRpfList(IAbsoluteDirectoryPath rpfListPath)
 {
     IReadOnlyCollection<IRelativeFilePath> rpfList = null;
     var rpfDataListFile = rpfListPath.GetChildFileWithName(RpfdataList);
     if (rpfDataListFile.Exists)
     {
         Console.WriteLine("Found {0}, will check package config for validity.", rpfDataListFile);
         rpfList = File.ReadAllLines(rpfDataListFile.ToString()).Select(x => x.ToRelativeFilePath()).ToArray();
     }
     else
     {
         Console.WriteLine("Missing {0}, will NOT check package config for validity.", RpfdataList);
     }
     return rpfList;
 }
 public async Task Uninstall(IAbsoluteDirectoryPath destination, Settings settings,
     params IAbsoluteFilePath[] files) {
     var theShell = GetTheShell(destination, files);
     try {
         RunSrm(theShell, "uninstall");
         await RestartExplorer().ConfigureAwait(false);
         foreach (var d in files.Select(f => destination.GetChildFileWithName(f.FileName)).Where(d => d.Exists))
             d.Delete();
     } catch (ProcessExitException ex) {
         // Already uninstalled..
         if (ex.ExitCode != 255)
             throw;
     }
     settings.ExtensionUninstalled();
 }
        protected static async Task BuildAndRunBatFile(IProcessManager pm, IAbsoluteDirectoryPath tmpFolder,
            IEnumerable<string> commands, bool asAdministrator = false, bool noisy = false) {
            var batFile = tmpFolder.GetChildFileWithName("install.bat");
            var actualCommands =
                new[] {"chcp 65001"}.Concat(commands)
                    .Concat(new[] {"echo finished"})
                    .Select(x => x == "" ? x : x + " >> install.log");
            var commandBat = string.Join("\r\n",
                new[] {"", "echo starting > install.log"}.Concat(actualCommands)
                    .Concat(new[] {""}));
            var encoding = Encoding.UTF8;
            File.WriteAllText(batFile.ToString(), commandBat, encoding);
            if (Common.Flags.Verbose || noisy)
                MainLog.Logger.Info("install.bat content:\n" + commandBat);

            try {
                var pInfo = new ProcessStartInfoBuilder(batFile) {
                    WorkingDirectory = tmpFolder
                    //WindowStyle = ProcessWindowStyle.Minimized
                }.Build();
                pInfo.CreateNoWindow = true;
                var basicLaunchInfo = new BasicLaunchInfo(pInfo) {StartMinimized = true};
                var r =
                    await (asAdministrator ? pm.LaunchElevatedAsync(basicLaunchInfo) : pm.LaunchAsync(basicLaunchInfo));
                r.ConfirmSuccess();
            } catch (Win32Exception ex) {
                if (ex.IsElevationCancelled())
                    throw ex.HandleUserCancelled();
                throw;
            }
            var logFile = tmpFolder.GetChildFileWithName("install.log");
            var output = File.ReadAllText(logFile.ToString(), encoding);

            if (Common.Flags.Verbose || noisy)
                MainLog.Logger.Info("install.bat output:\n" + output);
        }
Exemple #35
0
 protected override Task UninstallImpl()
 {
     if (!_installPath.Exists || !SourcePath.Exists)
     {
         return(TaskExt.Default);
     }
     foreach (var df in
              SourcePath.DirectoryInfo.EnumerateFiles()
              .Select(f => _installPath.GetChildFileWithName(f.Name))
              .Where(df => df.Exists))
     {
         df.Delete();
     }
     return(TaskExt.Default);
 }
Exemple #36
0
            void ValidateSteamExecutable()
            {
                _steamExe = _path.GetChildFileWithName(SteamInfos.SteamExecutable);
                if (_steamExe.Exists)
                {
                    return;
                }

                if (_requireExeExist)
                {
                    throw SteamExeDoesNotExist();
                }

                MainLog.Logger.Warn("Steam executable not found at {0}", _steamExe);
            }
Exemple #37
0
            private static async Task CreatePakFile(IAbsoluteDirectoryPath sourceDir, IAbsoluteDirectoryPath toolDir,
                                                    IAbsoluteFilePath sourcePakPath)
            {
                var r = await
                        Tools.ProcessManager.LaunchAndGrabAsync(
                    new BasicLaunchInfo(new ProcessStartInfo(
                                            toolDir.GetChildFileWithName(@"asset_packer.exe").ToString(),
                                            new[] { sourceDir.ToString(), sourcePakPath.ToString() }
                                            .CombineParameters()))).ConfigureAwait(false);

                if (r.ExitCode != 0)
                {
                    throw new Exception(
                              $"Failed creating a pak file for the mod. Code: {r.ExitCode} Output: {r.StandardOutput} Error: {r.StandardError}");
                }
            }
Exemple #38
0
            public Task Uninstall()
            {
                if (!_installPath.Exists || !_sourceDir.Exists)
                {
                    return(TaskExt.Default);
                }
                foreach (var df in
                         _sourceDir.DirectoryInfo.EnumerateFiles()
                         .Select(f => _installPath.GetChildFileWithName(f.Name))
                         .Where(df => df.Exists))
                {
                    df.Delete();
                }

                return(TaskExt.Default);
            }
Exemple #39
0
        void RestoreFileFromBackup(IAbsoluteDirectoryPath backupDir, string fileName)
        {
            var existingFile = InstalledState.Directory.GetChildFileWithName(fileName);

            if (existingFile.Exists)
            {
                return;
            }
            var backupFile = backupDir.GetChildFileWithName(fileName);

            if (!backupFile.Exists)
            {
                return;
            }
            backupFile.Copy(existingFile);
        }
        static bool InstallDll(IAbsoluteFilePath pluginPath, IAbsoluteDirectoryPath gamePluginFolder,
            bool force = true) {
            Contract.Requires<ArgumentNullException>(gamePluginFolder != null);
            Contract.Requires<ArgumentNullException>(pluginPath != null);

            if (!pluginPath.IsNotNullAndExists())
                throw new PathDoesntExistException(pluginPath.ToString());

            if (!gamePluginFolder.IsNotNullAndExists())
                throw new PathDoesntExistException(gamePluginFolder.ToString());

            var fullPath = gamePluginFolder.GetChildFileWithName(pluginPath.FileName);

            if (!force && fullPath.Exists)
                return false;

            return TryCopyDll(pluginPath, fullPath);
        }
 public async Task Initialize(IAbsoluteDirectoryPath gamePath, uint appId) {
     var r = await _steamApi.Do(x => {
         var managerConfigWrap = new ManagerConfigWrap {ConsumerAppId = appId};
         managerConfigWrap.Load(gamePath.GetChildFileWithName(@"Launcher\config.bin").ToString());
         return x.Init(managerConfigWrap);
     }).ConfigureAwait(false);
     if (r == InitResult.SteamNotRunning)
         throw new SteamInitializationException(
             "Steam initialization failed. Is Steam running under the same priviledges?");
     if (r == InitResult.APIInitFailed)
         throw new SteamInitializationException(
             "Steam initialization failed. Is Steam running under the same priviledges?");
     if (r == InitResult.ContextCreationFailed)
         throw new SteamInitializationException(
             "Steam initialization failed. Is Steam running under the same priviledges?");
     if (r == InitResult.AlreadyInitialized)
         throw new SteamInitializationException(
             "Steam initialization failed. Already initialized");
     if (r == InitResult.Disabled)
         throw new SteamInitializationException(
             "Steam initialization failed. Disabled");
 }
 void InstallOfficialPatchInternal(string patchFile, IAbsoluteDirectoryPath tempPath, ITransferStatus status) {
     var filePath = tempPath.GetChildFileWithName(patchFile);
     Download(patchFile, status, filePath);
     status.Reset();
     InstallPatch(filePath, "-silent");
 }
 void DownloadAndInstallCommunityPatchInternal(string patchFile, IAbsoluteDirectoryPath destinationPath,
     ITransferStatus status, IAbsoluteDirectoryPath gamePath) {
     var filePath = destinationPath.GetChildFileWithName(patchFile);
     Download(patchFile, status, filePath);
     status.Reset();
     var gameFilePath = gamePath.GetChildFileWithName(filePath.FileName);
     Tools.Compression.Unpack(filePath, gamePath, true, true, true);
     try {
         InstallPatch(gameFilePath, "-silent -incurrentfolder");
     } finally {
         gameFilePath.FileInfo.Delete();
     }
 }
Exemple #44
0
 public Task CreateBatFile(IAbsoluteDirectoryPath path, string name, string content) {
     return
         Ops.CreateTextAsync(
             path.GetChildFileWithName(MakeValidBatFileName(name)), content);
 }
 static void WriteBundleToDisk(Bundle bundle, IAbsoluteDirectoryPath destination) {
     Repository.SaveDto(CreateBundleDto(bundle),
         destination.GetChildFileWithName(GetBundleFileName(bundle)));
 }
 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);
     }
 }
 void SetSixSyncPaths() {
     var path = Path;
     _repoPath = path == null ? null : path.GetChildDirectoryWithName(Repository.RepoFolderName);
     _repoYamlFile = _repoPath == null ? null : _repoPath.GetChildFileWithName(Repository.VersionFileName);
     _repoConfigYamlFile = _repoPath == null
         ? null
         : _repoPath.GetChildFileWithName(Repository.ConfigFileName);
 }
 public static void InitializeConfig(IAbsoluteDirectoryPath path) {
     var configFile = path.GetChildFileWithName(ConfigFileName);
     MainConfig = configFile.Exists
         ? SyncEvilGlobal.Yaml.NewFromYamlFile<RepoMainConfig>(configFile)
         : new RepoMainConfig();
 }
 public async Task<bool> CheckUac(IAbsoluteDirectoryPath mp) => Tools.UacHelper.CheckUac() &&
                                                                await
                                                                    TryCheckUac(mp,
                                                                            mp.GetChildFileWithName(
                                                                                "_play_withSIX_testFile.txt"))
                                                                        .ConfigureAwait(false);
Exemple #50
0
 public void PackageMod(IAbsoluteDirectoryPath modPackagePath)
 {
     var packageConfig = ReadXmlFile(modPackagePath.GetChildFileWithName(PackageConfigFileName));
     var list = _rpfListBuilder.BuildRpfList(modPackagePath, packageConfig);
     foreach (var rpf in list)
         ProcessModdedRpf(rpf);
 }
 Task DownloadFileAsync(string remoteFile, IAbsoluteDirectoryPath destinationPath,
         IMirrorSelector scoreMirrorSelector, CancellationToken token,
         Func<IAbsoluteFilePath, bool> confirmValidity, int zsyncHttpFallbackAfter)
     => DownloadFileAsync(remoteFile, destinationPath.GetChildFileWithName(remoteFile), scoreMirrorSelector,
         token, confirmValidity, zsyncHttpFallbackAfter);
 public static void WritePackageConfig(IAbsoluteDirectoryPath path, IAbsoluteDirectoryPath rpfListPath)
 {
     var rpfList = GetRpfList(rpfListPath);
     var output = Build(path, rpfList);
     File.WriteAllText(path.GetChildFileWithName("package.config").ToString(), output);
 }
 private IAbsolutePath GetPath(IAbsoluteDirectoryPath workshopPath)
     =>
     IsLegacy()
         ? (IAbsolutePath) workshopPath.GetChildFileWithName(Pid.ToString())
         : workshopPath.GetChildDirectoryWithName(Pid.ToString());
        public IronFrontInfo(IAbsoluteDirectoryPath ironFrontPath, IAbsoluteDirectoryPath gamePath,
            IAbsoluteDirectoryPath tempPath, IfaStatus status, IfaGameEdition game) {
            IronFrontPath = ironFrontPath;
            GamePath = gamePath;
            TempPath = tempPath;

            Status = status;
            Game = game;

            IronFrontExePath = ironFrontPath.GetChildFileWithName("ironfront.exe");
            IFSourcePath = ironFrontPath.GetChildDirectoryWithName("IF");
            IFDlcSourcePath = ironFrontPath.GetChildDirectoryWithName("DLC_1");
            GameIFPath = gamePath.GetChildDirectoryWithName("@IF");
            GameIFDlcPath = gamePath.GetChildDirectoryWithName("@LIB_DLC_1");
            GameIF3MPath = gamePath.GetChildDirectoryWithName("@IFA3M");
            GameIFOtherAddonsPath = gamePath.GetChildDirectoryWithName("@IF_Other_Addons");
        }
        static string GetUserconfigPath(IAbsoluteDirectoryPath modPath) {
            var storePath = modPath.GetChildDirectoryWithName("store");
            var path = storePath.GetChildFileWithName("userconfig.tar");
            if (path.Exists)
                return path.ToString();

            path = modPath.GetChildFileWithName("userconfig.tar");
            if (path.Exists)
                return path.ToString();

            var dir = storePath.GetChildDirectoryWithName("userconfig");
            if (!dir.Exists)
                dir = modPath.GetChildDirectoryWithName("userconfig");
            return dir.ToString();
        }
Exemple #56
0
 static IAbsoluteFilePath GetDefaultPrivateKeyPath(IAbsoluteDirectoryPath keyPath, string prefix,
     IAbsoluteDirectoryPath arg) {
     return
         keyPath.GetChildFileWithName((prefix ?? String.Empty) + arg.DirectoryName.Replace("@", String.Empty) +
                                      ".biprivatekey");
 }
Exemple #57
0
            static void UnpackArchive(IAbsoluteDirectoryPath outputFolder, bool overwrite, IArchive archive,
                ExtractOptions options) {
                foreach (var p in archive.Entries.Where(entry => entry.IsDirectory)
                    .Select(entry => outputFolder.GetChildDirectoryWithName(entry.Key)))
                    p.MakeSurePathExists();

                foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory)) {
                    if (overwrite)
                        options = options | ExtractOptions.Overwrite;

                    if (!overwrite) {
                        if (!outputFolder.GetChildFileWithName(entry.Key).Exists)
                            entry.WriteToDirectory(outputFolder.ToString(), options);
                    } else
                        entry.WriteToDirectory(outputFolder.ToString(), options);
                }
            }
        static bool InstallDll(IAbsoluteFilePath fi, IAbsoluteDirectoryPath destination, string subPath = null,
            bool force = true) {
            Contract.Requires<ArgumentNullException>(destination != null);

            if (!destination.Exists)
                throw new PathDoesntExistException(destination.ToString());
            if (subPath != null)
                destination = destination.GetChildDirectoryWithName(subPath);
            var fullPath = destination.GetChildFileWithName(fi.FileName);

            if (!force && fullPath.Exists)
                return false;

            return TryCopyDll(fi, fullPath);
        }
 private static IAbsoluteFilePath GetTheShell(IAbsoluteDirectoryPath destination, IAbsoluteFilePath[] files)
     => destination.GetChildFileWithName(files.First().FileName);
 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);
     }
 }