private static void BuildReadme(IList <Package> packages, IList <Sync> syncList)
{
_logger.Information("Building Readme ...");
int packageCnt = 0;
var builder = new StringBuilder(32727);
var outputPath = "KrustWB3.readme.txt";
foreach (var package in packages)
{
ProgressBar.DrawProgressBar("BuildReadme ", packageCnt++, packages.Count);
builder.AppendLine($"{package.Path}");
builder.AppendLine($"{new string('=', package.Path.Length)}");
builder.AppendLine($"Category: [{package.Category}]");
builder.AppendLine($"Source {package.Source}");
builder.AppendLine($"{package.Description}");
builder.AppendLine($"");
}
syncList.Add(new Sync
{
PackageContentBasePath = "KrustWB3.readme.txt",
SyncType = SyncType.SourceToTarget,
FileType = FileType.File,
SourcePath = outputPath,
TargetPath = outputPath
});
FileHandlerFactory.AddCustomFileHandler(outputPath, new InmemoryFileHandler(outputPath, builder.ToString(), new Attributes((byte)0x00)));
ProgressBar.ClearProgressBar();
//_logger.Information("Build Readme done!");
}
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);
}
}
}
}
}
