Example #1
0
        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);
            }
        }
Example #2
0
        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);
        }
Example #3
0
        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);
        }
Example #5
0
        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));
        }
Example #6
0
        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;
        }
Example #7
0
 private void CompressPatch()
 {
     Compressor.Compress(
         _context.Settings.GetPatchesTempFolderPath(),
         PathsManager.Combine(_context.Settings.GetPatchesFolderPath(), _context.PatchName),
         null,
         _context.CompressionLevel
         );
 }
Example #8
0
        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();
        }
Example #9
0
        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);
        }
Example #10
0
        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);
        }
Example #11
0
        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);
        }
Example #12
0
        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());
        }
Example #13
0
        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);
     }
 }
Example #15
0
 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);
     }
 }
Example #16
0
        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);
        }
Example #17
0
        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);
            }
        }
Example #19
0
        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;
        }
Example #20
0
        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();
        }
Example #23
0
        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;
        }
Example #24
0
        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);
        }
Example #26
0
        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);
        }
Example #28
0
        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));
        }
Example #29
0
        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));
        }
Example #30
0
 public virtual string GetLogsDirectoryPath() => PathsManager.Combine(RootPath, LogsFolderName);
Example #31
0
 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);