private static void BuildUserStartup(IList <Config> configs, IList <Sync> syncList) { _logger.Information("Building user-startup ..."); var configCnt = 0; var builder = new StringBuilder(32727); var path = "user-startup"; var innerPath = "s\\user-startup"; foreach (var config in configs) { configCnt++; var packageCnt = 0; var packages = GetIncludedPackages(config); foreach (var package in packages) { ProgressBar.DrawProgressBar($"Build user-startup {configCnt}", packageCnt++, packages.Count); var packagFolderBasePath = _pathService.Combine(config.SourceBasePath, package.Path, ""); using (var fileHandler = FileHandlerFactory.Create(_logger, packagFolderBasePath)) { if (fileHandler.FileExists(path)) { var userstartup = fileHandler.FileReadAllText(path); if (userstartup.Contains(Environment.NewLine)) { _logger.Warning($"user-starttup for {package.Path} has incorrect NewLine! Correct NewLine is '\\n'"); userstartup = userstartup.Replace(Environment.NewLine, "\n"); } builder.Append(userstartup); if (userstartup.EndsWith('\n') == false) { builder.Append("\n"); } builder.Append("\n"); } } } } syncList.Add(new Sync { PackageContentBasePath = path, SyncType = SyncType.SourceToTarget, FileType = FileType.File, SourcePath = innerPath, TargetPath = innerPath }); var str = builder.ToString(); FileHandlerFactory.AddCustomFileHandler(path, new InmemoryFileHandler(innerPath, str, new Attributes((byte)0x40))); // 0x40 = S ProgressBar.ClearProgressBar(); //_logger.Information("Build user-startup done!"); }
private static void BuildIt(IList <Config> configs) { foreach (var config in configs) { _logger.Information(""); _logger.Information("Building from {SourcePath} to {TargetPath} ...", config.SourceBasePath, config.OutputBasePath); using (var outputFileHandler = FileHandlerFactory.Create(_logger, config.OutputBasePath)) { AliasService aliasService = new AliasService(config.Aliases); outputFileHandler.CreateBasePaths(aliasService); var syncList = BuildSyncList(outputFileHandler, config, aliasService); if (config.UserStartup) { BuildUserStartup(configs, syncList); } SynchronizeV2(syncList, outputFileHandler); } //_logger.Information("Build done"); } }
private static void SynchronizeV2(IList <Sync> syncList, IFileHandler outputFileHandler) { _logger.Information("Synchronizing ...", outputFileHandler.OutputBasePath); var targetPaths = syncList .Select(x => x.TargetPath.ToLowerInvariant()) .Distinct() .OrderBy(x => x) .ToList(); // Source Paths check is pure paranoia! Shouldn't be needed. var sourcePaths = syncList .Select(x => x.SourcePath?.ToLowerInvariant()) .Distinct() .ToList(); var packageCnt = 0; foreach (var targetPath in targetPaths) { ProgressBar.DrawProgressBar("SynchronizeV2", packageCnt++, targetPaths.Count); var syncListForTarget = syncList .Where(x => x.TargetPath.ToLowerInvariant() == targetPath) .ToList(); if (syncListForTarget.Count(x => x.FileType == FileType.Directory) > 0 && syncListForTarget.Count(x => x.FileType == FileType.File) > 0) { throw new Exception("syncListForTarget contains both FileType.Directory and FileType.File!"); } var syncCount = syncListForTarget.Count; var syncSkipList = syncListForTarget.GetRange(0, syncCount - 1); foreach (var sync in syncSkipList) { _logger.Debug("Sync (skipped) {Sync}", sync); } var actualSync = syncListForTarget.Last(); _logger.Debug("Sync {Sync})", actualSync); using (var contentFileHandler = FileHandlerFactory.Create(_logger, actualSync.PackageContentBasePath)) { switch (actualSync.FileType) { case FileType.File: SynchronizeFile(actualSync, contentFileHandler, outputFileHandler); break; case FileType.Directory: SynchronizeDirectory(actualSync, contentFileHandler, outputFileHandler); break; default: throw new ArgumentOutOfRangeException(); } } var syncListForTargetSourcePaths = syncListForTarget .Select(x => x.SourcePath?.ToLowerInvariant()) .ToList(); sourcePaths.RemoveAll(x => syncListForTargetSourcePaths.Contains(x)); } ProgressBar.ClearProgressBar(); // Source Paths check is pure paranoia! Shouldn't be needed. if (sourcePaths.Count > 0) { throw new Exception("SourcePaths was not synchronized!!"); } //_logger.Information("Synchronizing done!"); }
private static void AddContentToSyncList(string sourceBasePath, IFileHandler outputFileHandler, IList <Package> packages, string contentFolderName, SyncType syncType, List <Sync> syncList, AliasService aliasService) { int packageCnt = 0; foreach (var package in packages) { ProgressBar.DrawProgressBar($"AddContentToSyncList [{contentFolderName}]", packageCnt++, packages.Count); var packageContentFolderBasePath = _pathService.Combine(sourceBasePath, package.Path, contentFolderName); var packageContentLhaBasePath = _pathService.Combine(sourceBasePath, package.Path, contentFolderName + ".lha"); if (Directory.Exists(packageContentFolderBasePath) && File.Exists(packageContentLhaBasePath)) { throw new Exception($"Package [{package.Path}] has both [content] folder and [content.lha]."); } string packageContentBasePath; if (File.Exists(packageContentLhaBasePath)) { packageContentBasePath = packageContentLhaBasePath; } else if (Directory.Exists(packageContentFolderBasePath)) { packageContentBasePath = packageContentFolderBasePath; } else { continue; } using (var contentFileHandler = FileHandlerFactory.Create(_logger, packageContentBasePath)) { var packageOutputPath = ""; var sourcePath = ""; var packageEntries = contentFileHandler.DirectoryGetFileSystemEntriesRecursive(sourcePath); foreach (var packageEntry in packageEntries) { var outputPath = aliasService.TargetAliasToOutputPath(packageEntry); var packageEntryFileName = _pathService.GetFileName(outputPath); if (ShouldContentReverseAll(packageEntryFileName)) { var contentReversePackageEntryPath = _pathService.GetDirectoryName(outputPath); var contentReversePackageSubPath = RemoveRoot(sourcePath, contentReversePackageEntryPath); var contentReverseFileOutputPath = _pathService.Combine(packageOutputPath, contentReversePackageSubPath); if (outputFileHandler.DirectoryExists(contentReverseFileOutputPath)) { var innerContentReversePackageEntries = outputFileHandler.DirectoryGetFileSystemEntriesRecursive(contentReverseFileOutputPath); foreach (var innerContentReversePackageEntry in innerContentReversePackageEntries) { var innerContentReversePackageSubPath = RemoveRoot(packageOutputPath, innerContentReversePackageEntry); var innerContentReverseSourcePath = _pathService.Combine(sourcePath, innerContentReversePackageSubPath); var innerSync = new Sync { PackageContentBasePath = packageContentBasePath, SourcePath = innerContentReverseSourcePath, TargetPath = innerContentReversePackageEntry, SyncType = syncType, FileType = outputFileHandler.GetFileType(innerContentReversePackageEntry) }; syncList.Add(innerSync); } } } else { var packageSubPath = RemoveRoot(sourcePath, outputPath); var fileOutputPath = _pathService.Combine(packageOutputPath, packageSubPath); var sync = new Sync { PackageContentBasePath = packageContentBasePath, SourcePath = packageEntry, TargetPath = fileOutputPath, SyncType = syncType, FileType = contentFileHandler.GetFileType(packageEntry) }; syncList.Add(sync); } } } } }