void TarGzip(string path, string outputFile, bool insertCapitalizedOctoWrapper = false, bool insertCapitalizedDotNetWrapper = false)
{
var outFile = $"{outputFile}.tar.gz";
Logger.Info("Creating TGZ file {0} from {1}", outFile, path);
using (var tarMemStream = new MemoryStream())
{
using (var tar = WriterFactory.Open(tarMemStream, ArchiveType.Tar, new TarWriterOptions(CompressionType.None, true)))
{
// If using a capitalized wrapper, insert it first so it wouldn't overwrite the main payload on a case-insensitive system.
if (insertCapitalizedOctoWrapper)
{
tar.Write("Octo", AssetDirectory / "OctoWrapper.sh");
}
else if (insertCapitalizedDotNetWrapper)
{
tar.Write("Octo", AssetDirectory / "octo");
}
// Add the remaining files
tar.WriteAll(path, "*", SearchOption.AllDirectories);
}
tarMemStream.Seek(0, SeekOrigin.Begin);
using (Stream stream = File.Open(outFile, FileMode.Create))
using (var zip = WriterFactory.Open(stream, ArchiveType.GZip, CompressionType.GZip))
{
zip.Write($"{outputFile}.tar", tarMemStream);
}
}
Logger.Info("Successfully created TGZ file: {0}", outFile);
}
/// <summary>
/// Create an archive from a directory. It will iterate through all directories recursively.
/// </summary>
/// <param name="folderPath">Folder/directory to archive</param>
/// <param name="outputFile">Ouput path, including file name, of the resulting archive</param>
/// <param name="useZip">true for zip format; false for tar.gz format</param>
static public void CreateArchive(string folderPath, string outputFile, bool useZip)
{
using (var outputStream = File.OpenWrite(outputFile))
{
ArchiveType atype;
var cinfo = new CompressionInfo();
if (useZip)
{
atype = ArchiveType.Zip;
cinfo.Type = CompressionType.Deflate;
cinfo.DeflateCompressionLevel = SharpCompress.Compressor.Deflate.CompressionLevel.Default;
}
else
{
atype = ArchiveType.Tar;
cinfo.Type = CompressionType.GZip;
cinfo.DeflateCompressionLevel = SharpCompress.Compressor.Deflate.CompressionLevel.Default;
}
using (var awriter = WriterFactory.Open(outputStream, atype, cinfo))
{
awriter.WriteAll(folderPath, "*", SearchOption.AllDirectories);
}
}
}
public static async Task <FileCreationTaskResult> CreateArchiveFromFile(string file, string archiveFilePath, CancellationToken?token = null)
{
try
{
if (token == null)
{
token = CancellationToken.None;
}
using (var zip = File.OpenWrite(archiveFilePath))
using (var zipWriter = WriterFactory.Open(zip, ArchiveType.Zip, CompressionType.Deflate))
{
Log.Here().Activity($"Saving {file} to archive at '{archiveFilePath}'.");
await WriteZipAsync(zipWriter, Path.GetFileName(file), file, token.Value);
return(FileCreationTaskResult.Success);
}
}
catch (Exception ex)
{
if (!token.Value.IsCancellationRequested)
{
Log.Here().Error($"Error writing archive to '{archiveFilePath}': {ex.ToString()}");
}
else
{
Log.Here().Warning($"Cancelled writing archive \"{archiveFilePath}\".");
return(FileCreationTaskResult.Skipped);
}
}
return(FileCreationTaskResult.Error);
}
public void Pack(Stream outputZipStream, IEnumerable <AcCommonObject> objs)
{
var list = objs.ToList();
var description = PackedDescription.ToString(list.Select(GetDescriptionOverride));
using (var writer = WriterFactory.Open(outputZipStream, ArchiveType.Zip, CompressionType.Deflate)) {
_writer = writer;
_added.Clear();
foreach (var obj in list)
{
Drain(Pack(obj), _cancellation);
if (_cancellation.IsCancellationRequested)
{
return;
}
}
if (!string.IsNullOrWhiteSpace(description))
{
writer.WriteString("ReadMe.txt", description);
}
}
if (!string.IsNullOrEmpty(description))
{
outputZipStream.AddZipDescription(description);
}
}
public static void Compress(
string entryPath,
Stream inStream,
Stream outStream,
ArchiveType archiveType,
CompressionType compressionType,
ProgressStreamReportDelegate progressCallback)
{
char[] dirSeparators = { '\\', '/' };
if (progressCallback != null)
{
outStream = new ProgressStream(outStream);
((ProgressStream)outStream).BytesWritten += progressCallback;
}
using (var writer = WriterFactory.Open(outStream, archiveType, new WriterOptions(compressionType)))
{
writer.Write(entryPath, inStream);
}
if (progressCallback != null)
{
((ProgressStream)outStream).BytesWritten -= progressCallback;
}
}
public static string BuildSamplePackage(string name, string version)
{
var sourceDirectory = TestEnvironment.GetTestPath("Fixtures", "Deployment", "Packages", name);
var output = Path.Combine(Path.GetTempPath(), "CalamariTestPackages");
Directory.CreateDirectory(output);
var outputTarFilename = Path.Combine(output, name + "." + version + ".tar.gz");
if (File.Exists(outputTarFilename))
{
File.Delete(outputTarFilename);
}
using (Stream stream = File.OpenWrite(outputTarFilename))
using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)
{
LeaveStreamOpen = false
}))
{
writer.WriteAll(sourceDirectory, "*", SearchOption.AllDirectories);
}
return(outputTarFilename);
}
private static async IAsyncEnumerable <object> Work(List <Tuple <string, FileTreeNode> > items, int bufferSize)
{
await using var memoryStream = new MemoryStream();
var writer = WriterFactory.Open(memoryStream, ArchiveType.Zip, CompressionType.Deflate);
for (var i = 0; i < items.Count; i++)
{
var(name, node) = items[i];
await using var readStream = node.OpenRead();
writer.Write(name, readStream);
if (i == items.Count - 1)
{
writer.Dispose();
}
if (memoryStream.Position < bufferSize)
{
continue;
}
int pos;
for (pos = 0; pos <= memoryStream.Position - bufferSize; pos += bufferSize)
{
var data = new ReadOnlySequence <byte>(memoryStream.GetBuffer(), pos, bufferSize);
yield return(data);
}
if (memoryStream.Position > pos)
{
Array.Copy(memoryStream.GetBuffer(), pos, memoryStream.GetBuffer(), 0, memoryStream.Position - pos);
}
memoryStream.Seek(memoryStream.Position - pos, SeekOrigin.Begin);
}
yield return(new ReadOnlySequence <byte>(memoryStream.GetBuffer(), 0, (int)memoryStream.Position));
}
public static void Compress(
string rootDir,
IEnumerable <FileInfo> files,
Stream outStream,
ArchiveType archiveType,
CompressionType compressionType,
ProgressStreamReportDelegate progressCallback)
{
char[] dirSeparators = { '\\', '/' };
if (progressCallback != null)
{
outStream = new ProgressStream(outStream);
((ProgressStream)outStream).BytesWritten += progressCallback;
}
int rootDirLen = rootDir.Length + (dirSeparators.Contains(rootDir.Last()) ? 0 : 1);
using (var writer = WriterFactory.Open(outStream, archiveType, new WriterOptions(compressionType)))
{
foreach (FileInfo f in files)
{
writer.Write(f.FullName.Substring(rootDirLen), f);
}
}
if (progressCallback != null)
{
((ProgressStream)outStream).BytesWritten -= progressCallback;
}
}
public void PacketsDocumentation()
{
var builder = new StringBuilder();
builder.AppendLine("# NosCore.Packets's Documentation");
builder.AppendLine("## ClientPackets :");
foreach (IGrouping <string, Type> packetGroup in GetPacketsWithinNamespace("ClientPackets"))
{
builder.AppendLine();
builder.AppendLine($"### {packetGroup.Key}");
foreach (Type packet in GetPackets(packetGroup))
{
builder.AppendLine($"- [{packet.GetCustomAttribute<PacketHeaderAttribute>()!.Identification}](src/NosCore.Packets/ClientPackets/{packetGroup.Key}/{packet}.cs)");
}
}
builder.AppendLine();
builder.AppendLine("## ServerPackets :");
foreach (IGrouping <string, Type> packetGroup in GetPacketsWithinNamespace("ServerPackets"))
{
builder.AppendLine();
builder.AppendLine($"### {packetGroup.Key}");
foreach (Type packet in GetPackets(packetGroup))
{
builder.AppendLine($"- [{packet.GetCustomAttribute<PacketHeaderAttribute>()!.Identification}](src/NosCore.Packets/ServerPackets/{packetGroup.Key}/{packet}.cs)");
}
}
Approvals.Verify(WriterFactory.CreateTextWriter(builder.ToString(), "md"));
}
/// <summary>
/// 实现IHttpModule的Init接口
/// </summary>
/// <param name="app"></param>
public void Init(HttpApplication app)
{
// 确保配置文件已读取
WriterFactory.Init();
// 检查配置文件，是否启用 <Type DataType="ClownFish.Log.Model.PerformanceInfo, ClownFish.Log"
if( WriterFactory.Config.Types.FirstOrDefault(x => x.Type == typeof(PerformanceInfo)) == null ) {
throw new System.Configuration.ConfigurationErrorsException(
"启用 PerformanceModule 时，必需在 ClownFish.Log.config 的<Types>节点中注册 PerformanceInfo 数据类型。");
}
app.BeginRequest += App_BeginRequest;
if( WriterFactory.Config.Performance?.HttpExecuteTimeout > 0 ) {
// 启用 HttpHandler 性能监控
// 这里只记录 Handler 的执行时间，排除管线过程中HttpModule的执行时间
app.PreRequestHandlerExecute += app_PreRequestHandlerExecute;
app.PostRequestHandlerExecute += app_PostRequestHandlerExecute;
}
if( WriterFactory.Config.Performance?.DbExecuteTimeout > 0 ) {
// 启用数据库性能监控，注册扩展类型：EventManagerEventSubscriber
bool? flag = InternalBridge.RegisterEventManagerEventSubscriber?.Invoke();
// 说明：如果希望上面这行代码能正常工作，
// 必须在程序初始化时调用 ClownFish.Data.Initializer.Instance.XXX 来初始化ClownFish.Data
// 在 ClownFish.Data.Initializer 的构造方法中，会给 InternalBridge.RegisterEventManagerEventSubscriber 赋值
// 如果是第一次调用，再注册回调委托，供 EventManagerEventSubscriber 使用
if( flag.HasValue && flag.Value ) {
InternalBridge.PerformanceModuleCheckDbExecuteTime = CheckDbExecuteTime;
}
}
}
public void WriterFactory_MobileWriter()
{
Writer w = WriterFactory.Create(OutputDeviceType.Mobile);
//assert
Assert.IsInstanceOfType(w, typeof(MobileWriter));
}
private void Initialize(string configFileName)
{
try
{
var config = Config.Load(configFileName);
string validationText = config.ValidateErrors();
if (validationText == null)
{
m_currentConfig = config;
competitionCode.Text = config.CompetitionCode;
m_db = new Database(m_currentConfig);
m_scoresRepo = new QualificationScoresRepo(m_db);
m_tournamentRepo = new TournamentRepo(m_db);
m_Writer = WriterFactory.GetWriter(m_currentConfig);
GenerateNow.Enabled = true;
startPublishing.Enabled = true;
}
else
{
MessageBox.Show($"Config file validation failed.\r\n{validationText}");
}
}
catch (Exception ex)
{
MessageBox.Show($"Unable to open file.\n\r{ex.ToString()}");
}
}
static void Main(string[] args)
{
WriterType writeTo;
if (!Enum.TryParse <WriterType>(ConfigurationManager.AppSettings["WriteTo"], true, out writeTo))
{
Console.WriteLine("Invalid WriteTo option. Program is ending");
return;
}
var baseAddress = ConfigurationManager.AppSettings["HelloWorldDemoUrl"];
if (string.IsNullOrEmpty(baseAddress))
{
Console.WriteLine("HelloWorldDemoUrl not found. Program is ending");
return;
}
var client = new Client(new HttpClient(), baseAddress);
var writerFactory = new WriterFactory();
var worker = new Worker(client, writerFactory);
worker.RunHelloWordAsync(writeTo).GetAwaiter().GetResult();
Console.ReadKey();
}
public void CreateZipArchive(string filename, long files, long filesize, long chunksize, bool set_zip64, bool forward_only)
{
var data = new byte[chunksize];
// Use deflate for speed
var opts = new ZipWriterOptions(CompressionType.Deflate)
{
UseZip64 = set_zip64
};
// Use no compression to ensure we hit the limits (actually inflates a bit, but seems better than using method==Store)
var eo = new ZipWriterEntryOptions()
{
DeflateCompressionLevel = Compressors.Deflate.CompressionLevel.None
};
using (var zip = File.OpenWrite(filename))
using (var st = forward_only ? (Stream) new ForwardOnlyStream(zip) : zip)
using (var zipWriter = (ZipWriter)WriterFactory.Open(st, ArchiveType.Zip, opts))
{
for (var i = 0; i < files; i++)
{
using (var str = zipWriter.WriteToStream(i.ToString(), eo))
{
var left = filesize;
while (left > 0)
{
var b = (int)Math.Min(left, data.Length);
str.Write(data, 0, b);
left -= b;
}
}
}
}
}
protected void Write(CompressionType compressionType, string archive, string archiveToVerifyAgainst)
{
using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive))) {
WriterOptions writerOptions = new WriterOptions(compressionType)
{
LeaveStreamOpen = true,
};
writerOptions.ArchiveEncoding.Default = Encoding.GetEncoding(866);
using (var writer = WriterFactory.Open(stream, type, writerOptions))
{
writer.WriteAll(ORIGINAL_FILES_PATH, "*", SearchOption.AllDirectories);
}
}
CompareArchivesByPath(Path.Combine(SCRATCH2_FILES_PATH, archive),
Path.Combine(TEST_ARCHIVES_PATH, archiveToVerifyAgainst));
using (Stream stream = File.OpenRead(Path.Combine(SCRATCH2_FILES_PATH, archive)))
{
ReaderOptions readerOptions = new ReaderOptions();
readerOptions.ArchiveEncoding.Default = Encoding.GetEncoding(866);
using (var reader = ReaderFactory.Open(new NonDisposingStream(stream), readerOptions))
{
reader.WriteAllToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions()
{
ExtractFullPath = true
});
}
}
VerifyFiles();
}
public void Tar_FileName_Exactly_100_Characters()
{
string archive = "Tar_FileName_Exactly_100_Characters.tar";
// create the 100 char filename
string filename = "filename_with_exactly_100_characters_______________________________________________________________X";
// Step 1: create a tar file containing a file with the test name
using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive)))
using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, CompressionType.None))
using (Stream inputStream = new MemoryStream())
{
StreamWriter sw = new StreamWriter(inputStream);
sw.Write("dummy filecontent");
sw.Flush();
inputStream.Position = 0;
writer.Write(filename, inputStream, null);
}
// Step 2: check if the written tar file can be read correctly
string unmodified = Path.Combine(SCRATCH2_FILES_PATH, archive);
using (var archive2 = TarArchive.Open(unmodified))
{
Assert.Equal(1, archive2.Entries.Count);
Assert.Contains(filename, archive2.Entries.Select(entry => entry.Key));
foreach (var entry in archive2.Entries)
{
Assert.Equal("dummy filecontent", new StreamReader(entry.OpenEntryStream()).ReadLine());
}
}
}
public static void Verify(IExecutableQuery query)
{
Verify(
WriterFactory.CreateTextWriter(query.GetQuery()),
GetDefaultNamer(),
new ExecutableQueryFailure(query, GetReporter()));
}
public static void SendData([NotNull] string name, [NotNull] object obj)
{
using (var memory = new MemoryStream()) {
using (var writer = WriterFactory.Open(memory, ArchiveType.Zip, CompressionType.Deflate)) {
try {
writer.WriteString(name, JsonConvert.SerializeObject(obj));
} catch (Exception e) {
Logging.Warning($"Can’t attach {obj}: " + e);
}
}
var data = memory.ToArray();
if (data.Length > 20000000)
{
File.WriteAllBytes(FilesStorage.Instance.GetTemporaryFilename("Data.zip"), data);
throw new Exception("Size limit exceeded");
}
#if DEBUG
File.WriteAllBytes(FilesStorage.Instance.GetTemporaryFilename("Data.zip"), data);
#endif
InternalUtils.SendData(memory.ToArray(), $@"Name: {GetUserName()}
Operating system: {GetWindowsName()}
App version: {BuildInformation.AppVersion}", CmApiProvider.UserAgent);
}
}
public void TestSharpCompressWithEmptyStream()
{
MemoryStream stream = new NonSeekableMemoryStream();
using (IWriter zipWriter = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
{
zipWriter.Write("foo.txt", new MemoryStream(new byte[0]));
zipWriter.Write("foo2.txt", new MemoryStream(new byte[10]));
}
stream = new MemoryStream(stream.ToArray());
File.WriteAllBytes("foo.zip", stream.ToArray());
using (var zipArchive = ZipArchive.Open(stream))
{
foreach (var entry in zipArchive.Entries)
{
using (var entryStream = entry.OpenEntryStream())
{
MemoryStream tempStream = new MemoryStream();
const int bufSize = 0x1000;
byte[] buf = new byte[bufSize];
int bytesRead = 0;
while ((bytesRead = entryStream.Read(buf, 0, bufSize)) > 0)
{
tempStream.Write(buf, 0, bytesRead);
}
}
}
}
}
private static void CreateUpdatePackage(string artifactsDir,
string outputDir,
string productVersion)
{
var updateDir = Path.Combine(outputDir, "Update-ToZip");
Directory.CreateDirectory(updateDir);
FileHelper.CopyDirectory(artifactsDir, updateDir);
using (var stream = File.OpenWrite(Path.Combine(outputDir, productVersion + ".tar.lz")))
{
var writerOptions = new WriterOptions(CompressionType.LZip)
{
LeaveStreamOpen = false,
ArchiveEncoding = { Default = Encoding.GetEncoding(866) },
};
using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, writerOptions))
{
writer.WriteAll(updateDir, "*", SearchOption.AllDirectories);
}
}
Directory.Delete(updateDir, true);
}
public ActionResult WriterArchive(RenderModel model, int id, string name, FILTER filter = FILTER.Recommendations, int page = 1)
{
IPublishedContent recommendationsRespository = Helper.TypedContentAtRoot().FirstOrDefault()
.FirstChild(x => x.DocumentTypeAlias == Constants.NodeAlias.RECOMMENDATIONS_REPOSITORY);
IPublishedContent articleRespository = Helper.TypedContentAtRoot().FirstOrDefault()
.FirstChild(x => x.DocumentTypeAlias == Constants.NodeAlias.ARTICLE_REPOSISTORY);
IPublishedContent locationRespository = Helper.TypedContentAtRoot().FirstOrDefault()
.FirstChild(x => x.DocumentTypeAlias == Constants.NodeAlias.LOCATION_REPOSITORY);
WriterModel writerModel = WriterFactory
.Create(model.Content, recommendationsRespository, articleRespository, locationRespository, Site.IsEnglish, false, Services.ContentService, filter, page);
string expectedName = writerModel.Name.ToSeoUrl();
string actualName = (name ?? "").ToLower();
// permanently redirect to the correct URL
if (expectedName != actualName)
{
return(RedirectToActionPermanent(Constants.Controllers.WriterArchive.NAME,
Constants.Controllers.WriterArchive.Actions.INDEX,
new
{
id = writerModel.Id,
name = expectedName,
filter
}));
}
return(CurrentTemplate(writerModel));
}
public void WriterFactory_DatabaseWriter()
{
Writer w = WriterFactory.Create(OutputDeviceType.Database);
//assert
Assert.IsInstanceOfType(w, typeof(DatabaseWriter));
}
protected void Write(CompressionType compressionType, string archive, string archiveToVerifyAgainst)
{
ResetScratch();
using (Stream stream = File.OpenWrite(Path.Combine(SCRATCH2_FILES_PATH, archive)))
{
using (var writer = WriterFactory.Open(new NonDisposingStream(stream), type, new WriterOptions(compressionType)
{
LeaveStreamOpen = true
}))
{
writer.WriteAll(ORIGINAL_FILES_PATH, "*", SearchOption.AllDirectories);
}
if (!stream.CanWrite)
{
throw new InvalidOperationException();
}
}
CompareArchivesByPath(Path.Combine(SCRATCH2_FILES_PATH, archive),
Path.Combine(TEST_ARCHIVES_PATH, archiveToVerifyAgainst));
using (Stream stream = File.OpenRead(Path.Combine(SCRATCH2_FILES_PATH, archive)))
using (var reader = ReaderFactory.Open(new NonDisposingStream(stream)))
{
reader.WriteAllToDirectory(SCRATCH_FILES_PATH, new ExtractionOptions()
{
ExtractFullPath = true
});
}
VerifyFiles();
}
public async Task <DeviceSource> ConnectAsync(string port, UInt16 universe)
{
try
{
var writer = await WriterFactory.CreateDmxWriterAsync(port);
if (!Writers.Values.Any(x => x.UniverseID == universe))
{
// start listening on a new universe
SacnReceiver.JoinMulticastGroup(universe);
}
Writers.Add(port, new WriterEntry {
Writer = writer, UniverseID = universe
});
}
catch (Exception ex)
{
await Console.Error.WriteAsync(ex.ToString());
throw new ExecutionError(ex.Message);
}
return(new DeviceSource
{
Id = port,
Status = DeviceStatus.InUse,
Universe = universe
});
}
public static string BuildSamplePackage(string name, string version, bool excludeNonNativePlatformScripts = true)
{
var sourceDirectory = TestEnvironment.GetTestPath("Fixtures", "Deployment", "Packages", name);
var output = Path.Combine(Path.GetTempPath(), "CalamariTestPackages");
Directory.CreateDirectory(output);
var outputTarFilename = Path.Combine(output, name + "." + version + ".tar.gz");
if (File.Exists(outputTarFilename))
File.Delete(outputTarFilename);
using (Stream stream = File.OpenWrite(outputTarFilename))
using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip) {LeaveStreamOpen = false}))
{
var isRunningOnWindows = CalamariEnvironment.IsRunningOnWindows;
var files = Directory.EnumerateFiles(sourceDirectory, "*.*", SearchOption.AllDirectories)
.Select(f => new FileInfo(f))
.Where(f => isRunningOnWindows
? !IsNixNuspecFile(f)
: !IsNotANuspecFile(f) || IsNixNuspecFile(f));
if (excludeNonNativePlatformScripts)
files = files.Where(f => isRunningOnWindows ? f.Extension != ".sh" : f.Extension != ".ps1");
foreach(var file in files)
writer.Write(GetFilePathRelativeToRoot(sourceDirectory, file), file);
}
return outputTarFilename;
bool IsNixNuspecFile(FileInfo f) => f.Name.EndsWith(".Nix.nuspec");
bool IsNotANuspecFile(FileInfo f) => f.Name.EndsWith(".nuspec");
}
private void OnExportConfig(object sender, RoutedEventArgs e)
{
SaveFileDialog diag = new SaveFileDialog();
diag.Title = "Enter zip file";
diag.Filter = "Zip files|*.zip";
diag.DefaultExt = "zip";
if (diag.ShowDialog() == true)
{
System.IO.DirectoryInfo dirInfo = new System.IO.DirectoryInfo(Configuration.GetDataPath());
System.IO.FileInfo[] filesList = dirInfo.GetFiles();
using (var zipWriter = WriterFactory.Open(System.IO.File.OpenWrite(diag.FileName), ArchiveType.Zip, CompressionType.Deflate))
{
foreach (var filePath in filesList)
{
if (filePath.Name.ToUpperInvariant().EndsWith(".LOG") || filePath.Name.ToUpperInvariant().EndsWith(".PMO") || filePath.Name.ToUpperInvariant() == "CONFIG.DAT" || filePath.Name.ToUpperInvariant().EndsWith(".aio"))
{
try
{
zipWriter.Write(filePath.Name, filePath);
}
catch { }
}
}
}
MessageBox.Show("Configuration Export complete.");
}
}
/// <summary>
/// 获取要显示的日志根目录，
/// 重写这个方法可修改默认的根目录（FileWriter指定的目录）。
/// </summary>
/// <returns></returns>
public virtual string GetLogRootDirectory()
{
WriterFactory.Init();
WriterSection config = (from x in WriterFactory.Config.Writers
where x.Type.StartsWith(typeof(FileWriter).FullName + ",")
select x).FirstOrDefault();
if (config == null)
{
WriteMessage("ClownFish.Log.config中没有配置FileWriter");
return(null);
}
string path = config.GetOptionValue("RootDirectory");
if (string.IsNullOrEmpty(path))
{
WriteMessage("ClownFish.Log.config中，没有为FileWriter指定RootDirectory属性。");
return(null);
}
path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, path);
if (Directory.Exists(path) == false)
{
WriteMessage("ClownFish.Log.config中，为FileWriter指定RootDirectory目录不存在。");
return(null);
}
return(path);
}
public void TestSharpCompressWithEmptyStream()
{
ResetScratch();
MemoryStream stream = new NonSeekableMemoryStream();
using (IWriter zipWriter = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
{
zipWriter.Write("foo.txt", new MemoryStream(new byte[0]));
zipWriter.Write("foo2.txt", new MemoryStream(new byte[10]));
}
stream = new MemoryStream(stream.ToArray());
File.WriteAllBytes(Path.Combine(SCRATCH_FILES_PATH, "foo.zip"), stream.ToArray());
using (IReader zipReader = ZipReader.Open(stream))
{
while (zipReader.MoveToNextEntry())
{
using (EntryStream entry = zipReader.OpenEntryStream())
{
MemoryStream tempStream = new MemoryStream();
const int bufSize = 0x1000;
byte[] buf = new byte[bufSize];
int bytesRead = 0;
while ((bytesRead = entry.Read(buf, 0, bufSize)) > 0)
{
tempStream.Write(buf, 0, bytesRead);
}
}
}
}
}
/// <summary>
/// 以同步方式把消息写入日志
/// 如果需要写入到指定的持久化方式，可以直接调用相应的 Writter ，就不需要调用这个方法。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="info"></param>
public static void SyncWrite <T>(T info) where T : BaseInfo
{
// 触发日志的配置检查
WriterFactory.Init();
// 如果禁用日志写入就直接返回
if (WriterFactory.Config.Enable == false)
{
return;
}
// 忽略特定的对象类型
if (s_filter.Instance.IgnoreWrite(info))
{
return;
}
// 获取写日志的实例，注意：允许一个类型配置多个写入方式
ILogWriter[] writers = WriterFactory.CreateWriters(typeof(T));
// 如果类型没有配置日志序列化器，就忽略
if (writers == null || writers.Length == 0)
{
return;
}
foreach (var writer in writers)
{
writer.Write(info);
}
}
/**
* Compress the contents of given directory using Tar and Gzip to an in-memory byte array.
*
* @param sourceDirectory the source directory.
* @param pathPrefix a path to be prepended to every file name in the .tar.gz output, or {@code null} if no prefix is required.
* @param chaincodeMetaInf
* @return the compressed directory contents.
* @throws IOException
*/
public static byte[] GenerateTarGz(string sourceDirectory, string pathPrefix, string chaincodeMetaInf)
{
logger.Trace($"generateTarGz: sourceDirectory: {sourceDirectory}, pathPrefix: {pathPrefix}, chaincodeMetaInf: {chaincodeMetaInf}");
string sourcePath = sourceDirectory;
string[] sfiles = Directory.GetFiles(sourceDirectory, "*", SearchOption.AllDirectories);
string[] mfiles = chaincodeMetaInf != null?Directory.GetFiles(chaincodeMetaInf, "*", SearchOption.AllDirectories) : new string[0];
using (MemoryStream bos = new MemoryStream())
{
using (var writer = WriterFactory.Open(bos, ArchiveType.Tar, CompressionType.GZip))
{
foreach (string s in sfiles)
{
writer.Write(Path.Combine(pathPrefix ?? "", s.Substring(sourcePath.Length + 1)).Replace("\\", "/"), s);
}
if (chaincodeMetaInf != null)
{
foreach (string s in mfiles)
{
writer.Write(Path.Combine("META-INF", s.Substring(chaincodeMetaInf.Length + 1)).Replace("\\", "/"), s);
}
}
bos.Flush();
}
return(bos.ToArray());
}
}
public static void RegisterWriter(string scheme, WriterFactory factory)
{
writers.Add(scheme, factory);
}
