protected override void UpdateRestartNeeded(string executableName = "") { Data.Log(Context.LocalizedMessages.UpdateRestartNeeded); Context.Logger.Info($"===> [{UpdateProcessName}] process INCOMPLETE: restart is needed! <==="); string filePath; if (!string.IsNullOrWhiteSpace(executableName)) { filePath = PathsManager.Combine(Context.Settings.RootPath, executableName); } else { filePath = PathsManager.Combine(Context.Settings.RootPath, Data.LauncherExecutableName); } try { ApplicationStarter.StartApplication( Path.Combine(Context.Settings.RootPath, Data.LauncherExecutableName), ""); Data.Dispatcher.Invoke(Application.Quit); } catch (Exception ex) { Context.Logger.Error(null, $"Unable to start the Launcher at {filePath}."); UpdateFailed(ex); } }
private FileIntegrity GetRelaxedFileIntegrity(BuildDefinitionEntry entry) { foreach (var existingFile in _context.ExistingFiles) { var existingFilePath = FilesManager.SanitizePath(PathsManager.Combine(_context.Settings.RootPath, existingFile.RelativePath)); var entryFilePath = FilesManager.SanitizePath(PathsManager.Combine(_context.Settings.GetGamePath(), entry.RelativePath)); if (existingFilePath == entryFilePath) { var integrity = FileIntegrity.None; if (existingFile.Size != entry.Size) { integrity |= FileIntegrity.InvalidSize; } if (integrity == FileIntegrity.None) { return(FileIntegrity.Valid); } return(integrity); } } return(FileIntegrity.NotExisting); }
private void StartGame() { var filePath = PathsManager.Combine(Context.Settings.GetGamePath(), Data.GameExecutableName); ApplicationStarter.StartApplication(filePath, $"{Context.Settings.LaunchArgumentParameter}={Context.Settings.LaunchArgumentValue}"); Application.Quit(); }
private void EnsureDefinition(UpdaterDefinitionEntry entry) { var filePath = PathsManager.Combine(_context.Settings.RootPath, entry.RelativePath); File.SetAttributes(filePath, entry.Attributes); File.SetLastWriteTimeUtc(filePath, entry.LastWriting); }
private void BuildPatchDefinition(PatchDefinition definition) { definition.Hash = Hashing.GetFileHash(PathsManager.Combine(_context.Settings.GetPatchesFolderPath(), _context.PatchName)); definition.From = _context.VersionFrom; definition.To = _context.VersionTo; File.WriteAllText(_context.Settings.GetPatchIndexPath(_context.VersionFrom, _context.VersionTo), _context.Serializer.Serialize(definition)); }
private void HandleChangedAttributesFile(PatchDefinitionEntry entry) { var path = PathsManager.Combine(_context.Settings.GetGameFolderPath(_context.VersionTo), entry.RelativePath); var info = FilesManager.GetFileInfo(path); entry.Attributes = info.Attributes; entry.LastWriting = info.LastWriting; }
private void CompressPatch() { Compressor.Compress( _context.Settings.GetPatchesTempFolderPath(), PathsManager.Combine(_context.Settings.GetPatchesFolderPath(), _context.PatchName), null, _context.CompressionLevel ); }
private void InitializeSettings() { AdminSettings = new AdminSettings(); AdminSettings.RootPath = Path.Combine(Path.GetDirectoryName(Application.dataPath), WorkspaceFolderName); AdminSettings.AppDataPath = PathsManager.GetSpecialPath(Environment.SpecialFolder.ApplicationData); Localization = new EnglishAdminLocalizedMessages(); }
private void HandleAddedFile(PatchDefinition definition, PatchDefinitionEntry entry) { var sourcePath = PathsManager.Combine(_context.Settings.GetUncompressedPatchArchivePath(definition.From, definition.To), entry.RelativePath); var destinationPath = PathsManager.Combine(_context.Settings.GetGamePath(), entry.RelativePath); FilesManager.Delete(destinationPath); FilesManager.Move(sourcePath, destinationPath); EnsureDefinition(destinationPath, entry); }
protected override void UpdateRestartNeeded() { Data.Log(Context.LocalizedMessages.UpdateRestartNeeded); Context.Logger.Info($"===> [{UpdateProcessName}] process INCOMPLETE: restart is needed! <==="); EnsureExecutePrivileges(PathsManager.Combine(Context.Settings.RootPath, Data.LauncherExecutableName)); ApplicationStarter.StartApplication(Path.Combine(Context.Settings.RootPath, Data.LauncherExecutableName), ""); Data.Dispatcher.Invoke(Application.Quit); }
private bool HandleInvalidLastWriting(BuildDefinitionEntry entry) { var filePath = PathsManager.Combine(_context.Settings.GetGamePath(), entry.RelativePath); var hash = Hashing.GetFileHash(filePath); if (entry.Hash != hash) { FilesManager.Delete(filePath); return(false); } return(true); }
public void TestPathManager() { var pm = new PathsManager(); for (var i = 0; i < 30; i++) { pm.PushPath(i.ToString()); } Assert.AreEqual(10, pm.list().Count); Assert.AreEqual("29", pm.list().Last()); Assert.AreEqual("20", pm.list().First()); }
private void StartGame() { if (_alreadyTriggeredGameStart) { return; } _alreadyTriggeredGameStart = true; var filePath = PathsManager.Combine(Context.Settings.GetGamePath(), Data.GameExecutableName); ApplicationStarter.StartApplication(filePath, $"{Context.Settings.LaunchArgumentParameter}={Context.Settings.LaunchArgumentValue}"); Application.Quit(); }
private void ExecuteHandleFavoritePath(EventTranscriptionParameter <MouseButtonEventArgs> parameter) { if (ActiveView.IsFavoritePath) { ActiveView.IsFavoritePath = false; PathsManager.RemoveFavorite(ActiveView.FileSystem.CurrentPlace); } else { ActiveView.IsFavoritePath = true; PathsManager.AddFavorite(ActiveView.FileSystem.CurrentPlace); } }
public void EmtyNodesTest() { try { string[] node = { }; List<Link> links = new List<Link>(); PathsManager manager = new PathsManager(node, links); throw new Exception("done!"); } catch (Exception ex) { Assert.AreEqual("The specified Nodes list is invalid!", ex.Message); } }
public void InvalidTargetPathTest() { string[] node = "A B C D E F G H".Split(' '); var links = new List<Link>() { new Link("A", "B", 10), new Link("A", "C", 15), new Link("C", "H", 20), new Link("B", "H", 15) }; PathsManager manager = new PathsManager(node, links); var result = manager.GetLeastWeightedPath("A", "K"); Assert.AreEqual("The specified target path is not valid!", result.Message); }
public void NotSolucionTest() { string[] node = "A B C D E F G H".Split(' '); var links = new List<Link>() { new Link("A", "B", 10), new Link("A", "C", 15), new Link("C", "H", 20), new Link("B", "H", 15) }; PathsManager manager = new PathsManager(node, links); var result = manager.GetLeastWeightedPath("A", "D"); Assert.AreEqual("There is no solution for specifieds nodes!", result.Message); }
private void HandleDeletedFile(UpdaterDefinitionEntry entry) { var filePath = PathsManager.Combine(_context.Settings.RootPath, entry.RelativePath); if (FilesManager.IsFileLocked(filePath)) { var newFilePath = FilesManager.GetTemporaryDeletingFileName(filePath); FilesManager.Rename(filePath, newFilePath); } else { FilesManager.Delete(filePath); } }
protected override void UpdateRestartNeeded(string executableName = "") { Data.Dispatcher.Invoke(() => { Data.Log(Context.LocalizedMessages.UpdateRestartNeeded); }); Context.Logger.Info($"===> [{UpdateProcessName}] process INCOMPLETE: restart is needed! <==="); EnsureExecutePrivileges(PathsManager.Combine(Context.Settings.RootPath, Data.LauncherExecutableName)); string filePath; if (!string.IsNullOrWhiteSpace(executableName)) { filePath = PathsManager.Combine(Context.Settings.RootPath, executableName); } else { filePath = PathsManager.Combine(Context.Settings.RootPath, Data.LauncherExecutableName); } Data.Dispatcher.Invoke( () => { Data.Dialog.ShowDialog( "Pending update!", Context.LocalizedMessages.UpdateRestartNeeded, () => Data.Dialog.CloseDialog(), () => { try { ApplicationStarter.StartApplication( Path.Combine(Context.Settings.RootPath, Data.LauncherExecutableName), ""); Data.Dispatcher.Invoke(Application.Quit); } catch (Exception ex) { Context.Logger.Error(null, $"Unable to start the Launcher at {filePath}."); UpdateFailed(ex); } } ); RestartNeeded?.Invoke(); } ); _isPreviousUpdateCompleted = false; }
private static void CalculateLeastWeigtPath(List<string> lines) { string[] nodes = lines[0].Split(' '); List<Link> nodesLinks = new List<Link>(); if (lines.Count < 3) { Console.WriteLine("Invalid links"); return; } for (int i = 2; i <= lines.Count - 1; i++) { if (lines[i].Trim() == "") { break; } var linkValues = lines[i].Split(' '); if (linkValues.Length != 3) { Console.WriteLine("Invalid links"); return; } Link newLink = new Link(linkValues[0], linkValues[1], int.Parse(linkValues[2])); nodesLinks.Add(newLink); } string[] targetPath = lines[1].Split(' '); if (targetPath.Length != 2) { Console.WriteLine("Invalid target Path"); return; } PathsManager manager = new PathsManager(nodes, nodesLinks); PathResult result = manager.GetLeastWeightedPath(targetPath[0], targetPath[1]); if (result.Message != "") { Console.WriteLine(result.Message); } else { Console.WriteLine(string.Join(" ", result.Path)); } Console.WriteLine(result.TotalWeights); }
private void HandleAddedFile(UpdaterDefinitionEntry entry) { var filePath = PathsManager.Combine(_context.Settings.RootPath, entry.RelativePath); var difference = FileValidityDifference.None; var alreadyExisting = FilesManager.Exists(filePath); if (alreadyExisting && IsValid(entry, out difference)) { return; } if (difference.HasFlag(FileValidityDifference.Size)) { if (FilesManager.IsFileLocked(filePath)) { var newFilePath = FilesManager.GetTemporaryDeletingFileName(filePath); FilesManager.Rename(filePath, newFilePath); } else { FilesManager.Delete(filePath); } Downloader.Download(_context.Settings.GetRemoteUpdaterFileUrl(entry.RelativePath), PathsManager.GetDirectoryPath(filePath)); EnsureDefinition(entry); _context.SetDirtyFlag(entry.RelativePath); } else { if (!alreadyExisting) { Downloader.Download(_context.Settings.GetRemoteUpdaterFileUrl(entry.RelativePath), PathsManager.GetDirectoryPath(filePath)); } if (FilesManager.IsFileLocked(filePath)) { var newFilePath = FilesManager.GetTemporaryDeletingFileName(filePath); FilesManager.Rename(filePath, newFilePath); FilesManager.Copy(newFilePath, filePath); } EnsureDefinition(entry); } }
private static void EnsurePrivilegesMac(string filePath) { var filename = filePath + "/Contents/MacOS/" + PathsManager.GetFilename(filePath).Replace(".app", ""); var processChmod = new Process(); processChmod.StartInfo.FileName = "chmod"; processChmod.StartInfo.Arguments = "+x \"" + filename + "\""; processChmod.Start(); var processAttr = new Process(); processAttr.StartInfo.FileName = "xattr"; processAttr.StartInfo.Arguments = "-d com.apple.quarantine \"" + filePath + "\""; processAttr.Start(); }
private void HandleUpdatedFile(PatchDefinitionEntry entry) { var fromFile = PathsManager.Combine(_context.Settings.GetGameFolderPath(_context.VersionFrom), entry.RelativePath); var toFile = PathsManager.Combine(_context.Settings.GetGameFolderPath(_context.VersionTo), entry.RelativePath); var patchFile = PathsManager.Combine(_context.Settings.GetPatchesTempFolderPath(), entry.RelativePath + ".patch"); var signatureFile = PathsManager.Combine(_context.Settings.GetPatchesTempFolderPath(), entry.RelativePath + ".signature"); DirectoriesManager.Create(PathsManager.GetDirectoryPath(patchFile)); DeltaFileBuilder.Build(fromFile, toFile, patchFile, signatureFile); var path = PathsManager.Combine(_context.Settings.GetGameFolderPath(_context.VersionTo), entry.RelativePath); var info = FilesManager.GetFileInfo(path); entry.Attributes = info.Attributes; entry.LastWriting = info.LastWriting; }
protected override void UpdateCompleted() { Data.Log(Context.LocalizedMessages.UpdateProcessCompleted); Context.Logger.Info($"===> [{UpdateProcessName}] process COMPLETED! <==="); Data.Dispatcher.Invoke(() => { Data.ProgressBar.Progress = 1; Data.ProgressPercentage.text = "100%"; }); EnsureExecutePrivileges(PathsManager.Combine(Context.Settings.GetGamePath(), Data.GameExecutableName)); EnsureExecutePrivileges(PathsManager.Combine(Context.Settings.RootPath, Data.LauncherExecutableName)); Data.Dispatcher.Invoke(() => { Invoke(nameof(StartGame), 1.5f); }); }
private void HandleChangedAttributesFile(UpdaterDefinitionEntry entry) { var filePath = PathsManager.Combine(_context.Settings.RootPath, entry.RelativePath); if (!FilesManager.Exists(filePath)) { Downloader.Download(_context.Settings.GetRemoteUpdaterFileUrl(entry.RelativePath), PathsManager.GetDirectoryPath(filePath)); } else { if (FilesManager.IsFileLocked(filePath)) { var newFilePath = FilesManager.GetTemporaryDeletingFileName(filePath); FilesManager.Rename(filePath, newFilePath); FilesManager.Copy(newFilePath, filePath); } } EnsureDefinition(entry); }
private void HandleUpdatedFile(PatchDefinition definition, PatchDefinitionEntry entry) { var filePath = PathsManager.Combine(_context.Settings.GetGamePath(), entry.RelativePath); var fileBackupPath = filePath + ".bak"; var patchPath = PathsManager.Combine(_context.Settings.GetUncompressedPatchArchivePath(definition.From, definition.To), entry.RelativePath + ".patch"); try { FilesManager.Rename(filePath, fileBackupPath); DeltaFileApplier.Apply(fileBackupPath, patchPath, filePath); EnsureDefinition(filePath, entry); } catch { } finally { FilesManager.Delete(fileBackupPath); } }
private bool IsValid(UpdaterDefinitionEntry entry, out FileValidityDifference difference) { var filePath = PathsManager.Combine(_context.Settings.RootPath, entry.RelativePath); var info = FilesManager.GetFileInfo(filePath); difference = FileValidityDifference.None; if (info.Size != entry.Size) { difference |= FileValidityDifference.Size; } if (!AreLastWritingsEqual(info.LastWriting, entry.LastWriting)) { difference |= FileValidityDifference.LastWriting; } if (info.Attributes != entry.Attributes) { difference |= FileValidityDifference.Attributes; } return(difference == FileValidityDifference.None); }
private void BuildDefinition() { var files = FilesManager.GetFilesInfo(_context.Settings.GetApplicationFolderPath()); var definitions = new BuildDefinition(); definitions.Entries = new BuildDefinitionEntry[files.Length + 1]; for (var i = 0; i < files.Length; i++) { var file = files[i]; definitions.Entries[i] = new BuildDefinitionEntry() { Attributes = file.Attributes, Hash = Hashing.GetFileHash(PathsManager.Combine(_context.Settings.GetApplicationFolderPath(), file.RelativePath)), LastWriting = file.LastWriting, RelativePath = file.RelativePath, Size = file.Size }; _context.ReportProgress(string.Format(_context.LocalizedMessages.BuildDefinitionProcessed, PathsManager.GetFilename(file.RelativePath))); } var versionFile = FilesManager.GetFileInfo(_context.Settings.GetVersionFilePath(_context.BuildVersion)); definitions.Entries[files.Length] = new BuildDefinitionEntry() { Attributes = versionFile.Attributes, Hash = Hashing.GetFileHash(_context.Settings.GetVersionFilePath(_context.BuildVersion)), LastWriting = versionFile.LastWriting, RelativePath = versionFile.RelativePath, Size = versionFile.Size }; _context.ReportProgress(string.Format(_context.LocalizedMessages.BuildDefinitionProcessed, PathsManager.GetFilename(versionFile.RelativePath))); File.WriteAllText(_context.Settings.GetBuildDefinitionPath(_context.BuildVersion), _context.Serializer.Serialize(definitions)); }
public void TestB() { string[] node = "A B C D E F G H".Split(' '); var links = new List<Link>() { new Link("A", "B", 10), new Link("A", "C", 15), new Link("C", "H", 20), new Link("B", "H", 15), new Link("C", "D", 5), new Link("D", "G", 25), }; PathsManager manager = new PathsManager(node, links); var expectedResut = new PathResult(new List<string> { "A", "C", "D"}, 20); var result = manager.GetLeastWeightedPath("A", "D"); Assert.AreEqual(true, expectedResut.Equals(result)); }
public virtual string GetLogsDirectoryPath() => PathsManager.Combine(RootPath, LogsFolderName);
public virtual string GetLogsFilePath() => PathsManager.Combine(RootPath, LogsFolderName, LogsFileName);
public virtual string GetDebugReportFilePath() => PathsManager.Combine(RootPath, "debug_report.txt");
public virtual string GetUpdaterDeployPath(string fileName) => PathsManager.Combine(RootPath, fileName + ".zip");
public virtual string GetUpdaterIndexPath() => PathsManager.Combine(RootPath, UpdaterFolderName, UpdaterIndexFileName);
public virtual string GetVersionFilePath(IVersion version) => PathsManager.Combine(GetGameFolderPath(version), VersionFileName);