public static void BuildBundle(int version, string path, CompressOption compressOption, BuildTarget target, bool isReBuild)
{
EditorUtility.DisplayProgressBar("开始打包ab", "开始打包ab", 1f);
BeforeBuild();
BundleBuildConfig.outputPath = path;
BundleBuildConfig.VersionNum = version;
abPath = Application.dataPath + "/" + path + "/" + target.ToString() + "/Bundles";
if (isReBuild && Directory.Exists(abPath))
{
Directory.Delete(abPath, true);
}
if (!Directory.Exists(abPath))
{
Directory.CreateDirectory(abPath);
}
BuildAssetBundleOptions options = 0;
switch (compressOption)
{
case CompressOption.Uncompressed: options = options | BuildAssetBundleOptions.UncompressedAssetBundle; break;
case CompressOption.ChunkBasedCompression: options = options | BuildAssetBundleOptions.ChunkBasedCompression; break;
}
BuildPipeline.BuildAssetBundles(abPath, options, target);
AfterBuild();
AssetDatabase.Refresh();
EditorUtility.ClearProgressBar();
EditorUtility.DisplayDialog("打包完成", "打包完成", "ok");
}
public CompressOption GetTccCompressOption(string targetFolder, CompressionAlgo algo)
{
string src;
if (Files != null)
{
src = String.Join(" ", Files.Select(i => i.FullName));
}
else if (Directories != null)
{
src = String.Join(" ", Directories.Select(i => i.FullName));
}
else
{
throw new MissingMemberException();
}
Target = targetFolder;
var compressOption = new CompressOption
{
Algo = algo,
BlockMode = BlockMode.Individual,
SourceDirOrFile = src,
DestinationDir = Target,
Threads = Environment.ProcessorCount
};
return(compressOption);
}
private async Task <OperationSummary> Compress(PasswordMode passwordMode, CompressionAlgo algo,
string compressedFolder, string keysFolder, TestData data)
{
CompressOption compressOption = data.GetTccCompressOption(compressedFolder, algo);
compressOption.PasswordOption = await _benchmarkOptionHelper.GenerateCompressPasswordOption(passwordMode, keysFolder);
var resultCompress = await _tarCompressCrypt.Compress(compressOption);
return(resultCompress);
}
public async Task <OperationSummary> Compress(CompressOption option)
{
IEnumerable <Block> blocks = BlockHelper.PreprareCompressBlocks(option);
var sw = Stopwatch.StartNew();
var po = new ParallelizeOption
{
FailMode = option.FailFast ? Fail.Fast : Fail.Smart,
MaxDegreeOfParallelism = option.Threads
};
var operationBlocks = await blocks
.AsAsyncStream(_cancellationTokenSource.Token)
.CountAsync(out var counter)
// Prepare encyption
.ParallelizeStreamAsync(async(b, token) =>
{
await _encryptionCommands.PrepareEncryptionKey(b, option, token);
return(b);
}, po)
// Core loop
.ParallelizeStreamAsync(async(block, token) =>
{
_logger.LogInformation($"Starting {block.Source}");
CommandResult result = null;
try
{
string cmd = _compressionCommands.CompressCommand(block, option);
result = await cmd.Run(block.OperationFolder, token);
_logger.LogInformation($"Finished {block.Source} on {result?.ElapsedMilliseconds} ms");
}
catch (Exception e)
{
_logger.LogError(e, $"Error on {block.Source}");
}
return(new OperationBlock(block, result));
}, po)
// Cleanup loop
.ParallelizeStreamAsync(async(opb, token) =>
{
await _encryptionCommands.CleanupKey(opb.Block, option, opb.CommandResult, Mode.Compress);
return(opb);
}, po)
.ForEachAsync((i, ct) =>
{
_blockListener.OnBlockReport(new BlockReport(i.Item.CommandResult, i.Item.Block, counter.Count));
return(Task.CompletedTask);
})
.AsEnumerableAsync();
sw.Stop();
return(new OperationSummary(operationBlocks, option.Threads, sw));
}
public void setCompressAlgorithm(CompressOption algorithm)
{
switch (algorithm)
{
case CompressOption.lzma:
compresser = new LZMACompresser();
break;
case CompressOption.gzip:
compresser = new GZipCompresser();
break;
case CompressOption.zlib:
compresser = new ZlibCompresser();
break;
}
}
public static IEnumerable <Block> PreprareCompressBlocks(CompressOption compressOption)
{
IEnumerable <Block> blocks;
string extension = ExtensionFromAlgo(compressOption.Algo, compressOption.PasswordOption.PasswordMode != PasswordMode.None);
var srcDir = new DirectoryInfo(compressOption.SourceDirOrFile);
var dstDir = new DirectoryInfo(compressOption.DestinationDir);
switch (compressOption.BlockMode)
{
case BlockMode.Individual:
blocks = PrepareCompressBlockIndividual(extension, srcDir, dstDir).ToList();
break;
case BlockMode.Explicit:
blocks = PrepareCompressBlockExplicit(extension, compressOption.SourceDirOrFile, dstDir).ToList();
break;
case BlockMode.EachFile:
blocks = PrepareCompressBlockEachFile(extension, srcDir, dstDir).ToList();
break;
case BlockMode.EachFileRecursive:
blocks = PrepareCompressBlockEachFileRecursive(extension, srcDir, dstDir).ToList();
break;
default:
throw new NotImplementedException();
}
if (!dstDir.Exists)
{
dstDir.Create();
}
return(blocks);
}
public static TccCommand ParseCommandLine(this string[] args)
{
TccCommand command;
var parsed = CommandLine.Parser.Default.ParseArguments <CompressCmdOptions, DecompressOptions, BenchmarkOptions>(args);
try
{
command = parsed.MapResult(
(CompressCmdOptions opts) =>
{
var option = new CompressOption
{
Algo = opts.Algorithm,
CompressionRatio = opts.Ratio,
DestinationDir = opts.Output,
FailFast = opts.FailFast,
Verbose = opts.Verbose,
SourceDirOrFile = opts.Source.FirstOrDefault(),
BlockMode = opts.Individual ? BlockMode.Individual : BlockMode.Explicit,
Threads = ExtractThreads(opts)
};
ExtractPasswordInfo(opts, option, Mode.Compress);
return(new TccCommand
{
Mode = Mode.Compress,
Option = option
});
},
(DecompressOptions opts) =>
{
var option = new DecompressOption
{
DestinationDir = opts.Output,
FailFast = opts.FailFast,
Verbose = opts.Verbose,
SourceDirOrFile = opts.Source.FirstOrDefault(),
Threads = ExtractThreads(opts)
};
ExtractPasswordInfo(opts, option, Mode.Decompress);
return(new TccCommand
{
Mode = Mode.Decompress,
Option = option
});
},
(BenchmarkOptions opts) =>
{
bool IsExplicitMode()
{
return(!args.Any(i => BenchmarkOptions.AutoTestDataOptions.Contains(i)));
}
var option = new BenchmarkOption
{
Algorithm = opts.Algorithm,
Ratios = opts.Ratios,
Encrypt = opts.Encrypt,
Source = IsExplicitMode() ? opts.Source : null,
Content = opts.Content,
NumberOfFiles = opts.NumberOfFiles,
FileSize = opts.FileSize,
Threads = opts.Threads,
OutputCompressed = opts.OutputCompressed,
OutputDecompressed = opts.OutputDecompressed,
Cleanup = opts.Cleanup
};
return(new TccCommand
{
Mode = Mode.Benchmark,
BenchmarkOption = option
});
},
errs => new TccCommand {
ReturnCode = 1
});
}
catch (CommandLineException ae)
{
Console.Out.WriteLine(ae.Message);
return(new TccCommand {
ReturnCode = 1
});
}
catch (Exception e)
{
Console.Out.WriteLine(e.ToString());
return(new TccCommand {
ReturnCode = 1
});
}
return(command);
}
static public void export(String[] inputPathList, String[] outputPathList, CompressOption op, String prefix_primaryKey, String prefix_IgnoreSheet, String prefix_IgnoreLine, String prefix_IgnoreColumn, Boolean ignoreBlank, Boolean merge)
{
int i = 0;
int len = inputPathList.Length;
while (i < len)
{
export(inputPathList[i], outputPathList[i], op, prefix_primaryKey, prefix_IgnoreSheet, prefix_IgnoreLine, prefix_IgnoreColumn, ignoreBlank, merge);
i++;
}
}
static public void export(String inputPath, String outputPath, CompressOption op, String prefix_primaryKey, String prefix_IgnoreSheet, String prefix_IgnoreLine, String prefix_IgnoreColumn, Boolean ignoreBlank, Boolean merge)
{
if (Directory.Exists(inputPath))
{
DirectoryInfo di = new DirectoryInfo(inputPath);
FileInfo[] fileInfos = di.GetFiles("*.xls", SearchOption.AllDirectories);
for (int k = 0; k < fileInfos.Length; k++)
{
//如果不是隐藏文件 则解析
if ((fileInfos[k].Attributes & FileAttributes.Hidden) == 0)
{
export(fileInfos[k].FullName, outputPath, op, prefix_primaryKey, prefix_IgnoreSheet, prefix_IgnoreLine, prefix_IgnoreColumn, ignoreBlank, merge);
}
}
}
else
{
KTable[] sheets = doExport(inputPath, prefix_primaryKey, prefix_IgnoreSheet, prefix_IgnoreLine, prefix_IgnoreColumn, ignoreBlank, merge);
if (null == outputPath || "" == outputPath)
{
FileInfo fi = new FileInfo(inputPath);
outputPath = fi.DirectoryName;
}
if (!Directory.Exists(outputPath))
throw new Exception("导出路径\"" + outputPath + "\"不存在");
foreach (KTable sheet in sheets)
{
packager.reset();
packager.writeTable(sheet);
String path = outputPath + "/" + sheet.name + ".kk";
Byte[] bytes = packager.data;
MemoryStream inStream = new MemoryStream(bytes);
MemoryStream outStream = new MemoryStream();
ICompresser compresser;
switch (op)
{
case CompressOption.lzma:
compresser = new LZMACompresser();
compresser.compress(inStream, outStream);
break;
case CompressOption.zlib:
compresser = new ZlibCompresser();
compresser.compress(inStream, outStream);
break;
case CompressOption.none:
outStream = inStream;
break;
default:
throw new Exception();
}
FileStream fs = File.Create(path);
outStream.WriteTo(fs);
fs.Close();
outStream.Dispose();
}
}
}
public string CompressCommand(Block block, CompressOption option)
{
var cmd = new StringBuilder();
string ratio;
switch (option.Algo)
{
case CompressionAlgo.Lz4:
ratio = option.CompressionRatio != 0 ? $"-{option.CompressionRatio}" : string.Empty;
break;
case CompressionAlgo.Brotli:
ratio = option.CompressionRatio != 0 ? $"-q {option.CompressionRatio}" : string.Empty;
break;
case CompressionAlgo.Zstd:
ratio = option.CompressionRatio != 0 ? $"-{option.CompressionRatio}" : string.Empty;
break;
default:
throw new ArgumentOutOfRangeException(nameof(option), "Unknown PasswordMode");
}
switch (option.PasswordOption.PasswordMode)
{
case PasswordMode.None:
// tar -c C:\SourceFolder | lz4.exe -1 - compressed.tar.lz4
cmd.Append($"{_ext.Tar()} -c {block.Source}");
switch (option.Algo)
{
case CompressionAlgo.Lz4:
cmd.Append($" | {_ext.Lz4()} {ratio} -v - {block.DestinationArchive}");
break;
case CompressionAlgo.Brotli:
cmd.Append($" | {_ext.Brotli()} {ratio} - -o {block.DestinationArchive}");
break;
case CompressionAlgo.Zstd:
cmd.Append($" | {_ext.Zstd()} {ratio} - -o {block.DestinationArchive}");
break;
default:
throw new ArgumentOutOfRangeException(nameof(option), "Unknown PasswordMode");
}
break;
case PasswordMode.InlinePassword:
case PasswordMode.PasswordFile:
case PasswordMode.PublicKey:
string passwdCommand = PasswordCommand(option, block);
// tar -c C:\SourceFolder | lz4.exe -1 - | openssl aes-256-cbc -k "password" -out crypted.tar.lz4.aes
cmd.Append($"{_ext.Tar()} -c {block.Source}");
switch (option.Algo)
{
case CompressionAlgo.Lz4:
cmd.Append($" | {_ext.Lz4()} {ratio} -v - ");
break;
case CompressionAlgo.Brotli:
cmd.Append($" | {_ext.Brotli()} {ratio} - ");
break;
case CompressionAlgo.Zstd:
cmd.Append($" | {_ext.Zstd()} {ratio} - ");
break;
default:
throw new ArgumentOutOfRangeException(nameof(option), "Unknown PasswordMode");
}
cmd.Append($" | {_ext.OpenSsl()} aes-256-cbc {passwdCommand} -out {block.DestinationArchive}");
break;
default:
throw new ArgumentOutOfRangeException(nameof(option));
}
return(cmd.ToString());
}
public async Task <OperationSummary> RunBenchmark(BenchmarkOption benchmarkOption)
{
var operationSummaries = new List <OperationSummary>();
var keysFolder = TestFileHelper.NewFolder();
var iterations = await _iterationGenerator.PrepareIteration(benchmarkOption);
var threads = benchmarkOption.Threads == 0 ? Environment.ProcessorCount : benchmarkOption.Threads;
foreach (var iteration in iterations)
{
PasswordMode pm = iteration.Encryption ? PasswordMode.PublicKey : PasswordMode.None;
var compressedFolder = TestFileHelper.NewFolder(benchmarkOption.OutputCompressed);
var outputFolder = TestFileHelper.NewFolder(benchmarkOption.OutputDecompressed);
// compress
var compressOption = new CompressOption
{
Algo = iteration.Algo,
CompressionRatio = iteration.CompressionRatio,
BlockMode = BlockMode.Individual,
SourceDirOrFile = iteration.Content.Source,
DestinationDir = compressedFolder,
Threads = threads,
PasswordOption = await _benchmarkOptionHelper.GenerateCompressPasswordOption(pm, keysFolder)
};
OperationSummary resultCompress = await _tarCompressCrypt.Compress(compressOption);
if (_cancellationTokenSource.IsCancellationRequested)
{
await Cleanup();
return(null);
}
operationSummaries.Add(resultCompress);
resultCompress.ThrowOnError();
// decompress
var decompressOption = new DecompressOption
{
SourceDirOrFile = compressedFolder,
DestinationDir = outputFolder,
Threads = threads,
PasswordOption = _benchmarkOptionHelper.GenerateDecompressPasswordOption(pm, keysFolder)
};
OperationSummary resultDecompress = await _tarCompressCrypt.Decompress(decompressOption);
if (_cancellationTokenSource.IsCancellationRequested)
{
await Cleanup();
return(null);
}
operationSummaries.Add(resultDecompress);
resultDecompress.ThrowOnError();
StringBuilder sb = FormatResultSummary(iteration, resultCompress, resultDecompress);
Console.Out.WriteLine(sb.ToString());
async Task Cleanup()
{
if (benchmarkOption.Cleanup)
{
await "del /f /s /q * > NUL".Run(compressedFolder, CancellationToken.None);
Directory.Delete(compressedFolder, true);
await "del /f /s /q * > NUL".Run(outputFolder, CancellationToken.None);
Directory.Delete(outputFolder, true);
}
}
await Cleanup();
}
return(new OperationSummary(operationSummaries.SelectMany(i => i.OperationBlocks), 0, default));
}
static public void export(String[] inputPathList, String outputPath, CompressOption op, String prefix_primaryKey, String prefix_IgnoreSheet, String prefix_IgnoreLine, String prefix_IgnoreColumn, Boolean ignoreBlank)
{
commentRowNum--;
fieldNameRowNum--;
typeRowNum--;
dataRowStartNum--;
int i = 0;
int len = inputPathList.Length;
while (i < len)
{
export(inputPathList[i], outputPath, op, prefix_primaryKey, prefix_IgnoreSheet, prefix_IgnoreLine, prefix_IgnoreColumn, ignoreBlank);
i++;
}
Console.WriteLine("已生成代码至");
Console.WriteLine(codeFolderPath);
}
