| public SetComment ( string comment ) : void | ||
| comment | string | /// The comment text for the entire archive. /// |
| 리턴 | void | |
public void CommentTooLong()
{
MemoryStream ms = new MemoryStream();
ZipOutputStream s = new ZipOutputStream(ms);
s.SetComment(new String('A', 65536));
}
/// <summary>
/// 压缩多个文件/文件夹
/// </summary>
/// <param name="comment">注释信息</param>
/// <param name="password">压缩密码</param>
/// <param name="compressionLevel">压缩等级，范围从0到9，可选，默认为6</param>
/// <param name="filePaths">压缩文件路径</param>
/// <returns></returns>
private MemoryStream CreateZip(string comment, string password, int compressionLevel, params string[] filePaths)
{
MemoryStream memoryStream = new MemoryStream();
using (SharpZipLib.ZipOutputStream zipStream = new SharpZipLib.ZipOutputStream(memoryStream))
{
if (!string.IsNullOrWhiteSpace(password))
{
zipStream.Password = password;//设置密码
}
if (!string.IsNullOrWhiteSpace(comment))
{
zipStream.SetComment(comment);//添加注释
}
//设置压缩级别
zipStream.SetLevel(compressionLevel);
foreach (string item in filePaths)//从字典取文件添加到压缩文件
{
//如果不是文件直接跳过不打包
if (!File.Exists(item))
{
continue;
}
FileInfo fileInfo = new FileInfo(item);
using (FileStream fileStream = fileInfo.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
{
SharpZipLib.ZipEntry zipEntry = new SharpZipLib.ZipEntry(Path.GetFileName(item));
zipEntry.DateTime = fileInfo.LastWriteTime;
zipEntry.Size = fileStream.Length;
zipStream.PutNextEntry(zipEntry);
int readLength = 0;
byte[] buffer = new byte[bufferSize];
do
{
readLength = fileStream.Read(buffer, 0, bufferSize);
zipStream.Write(buffer, 0, readLength);
}while (readLength == bufferSize);
}
}
}
return(memoryStream);
}
void MakeZipFile(string name, string entryNamePrefix, int entries, int size, string comment)
{
using (FileStream fs = File.Create(name)) {
ZipOutputStream zOut = new ZipOutputStream(fs);
zOut.SetComment(comment);
for (int i = 0; i < entries; ++i)
{
zOut.PutNextEntry(new ZipEntry(entryNamePrefix + (i + 1).ToString()));
AddKnownDataToEntry(zOut, size);
}
zOut.Close();
fs.Close();
}
}
void MakeZipFile(string name, string[] names, int size, string comment)
{
using (FileStream fs = File.Create(name)) {
ZipOutputStream zOut = new ZipOutputStream(fs);
zOut.SetComment(comment);
for (int i = 0; i < names.Length; ++i)
{
zOut.PutNextEntry(new ZipEntry(names[i]));
AddKnownDataToEntry(zOut, size);
}
zOut.Close();
fs.Close();
}
}
private void WriteResources()
{
Tracer.Info(Tracer.Compiler, "CompilerClassLoader adding resources...");
// BUG we need to call GetTypeWrapperFactory() to make sure that the assemblyBuilder is created (when building an empty target)
ModuleBuilder moduleBuilder = this.GetTypeWrapperFactory().ModuleBuilder;
for (int i = 0; i < options.jars.Count; i++)
{
bool hasEntries = false;
MemoryStream mem = new MemoryStream();
using (ZipOutputStream zip = new ZipOutputStream(mem))
{
if (!string.IsNullOrEmpty(options.jars[i].Comment))
{
zip.SetComment(options.jars[i].Comment);
}
zip.SetLevel(9);
List<string> stubs = new List<string>();
foreach (Jar.Item item in options.jars[i])
{
if (item.IsStub)
{
// we don't want stub class pseudo resources for classes loaded from the file system
if (i != options.classesJar)
{
stubs.Add(item.Name);
}
continue;
}
ZipEntry zipEntry = item.ZipEntry;
if (options.compressedResources || zipEntry.CompressionMethod != CompressionMethod.Stored)
{
zipEntry.CompressionMethod = CompressionMethod.Deflated;
}
zip.PutNextEntry(zipEntry);
byte[] data = item.GetData();
zip.Write(data, 0, data.Length);
zip.CloseEntry();
hasEntries = true;
}
if (stubs.Count != 0)
{
// generate the --ikvm-classes-- file in the jar
ZipEntry zipEntry = new ZipEntry(JVM.JarClassList);
zipEntry.CompressionMethod = CompressionMethod.Deflated;
zip.PutNextEntry(zipEntry);
BinaryWriter bw = new BinaryWriter(zip);
bw.Write(stubs.Count);
foreach (string classFile in stubs)
{
bw.Write(classFile);
}
bw.Flush();
zip.CloseEntry();
hasEntries = true;
}
}
// don't include empty classes.jar
if (i != options.classesJar || hasEntries)
{
mem = new MemoryStream(mem.ToArray());
string name = options.jars[i].Name;
if (options.targetIsModule)
{
name = Path.GetFileNameWithoutExtension(name) + "-" + moduleBuilder.ModuleVersionId.ToString("N") + Path.GetExtension(name);
}
jarList.Add(name);
moduleBuilder.DefineManifestResource(name, mem, ResourceAttributes.Public);
}
}
}
public string GetArchiveFilename(string path, string newline, out string referenceName)
{
var commit = GetCommitByPath(ref path, out referenceName);
if (commit == null)
return null;
if (referenceName == null)
referenceName = commit.Sha;
var key = "archive";
if (newline != null)
key += newline.GetHashCode().ToString("x");
bool exist;
var filename = GitCache.GetCacheFilename(commit.Sha, key, out exist, true);
if (exist)
return filename;
using (var zipOutputStream = new ZipOutputStream(new FileStream(filename, FileMode.Create)))
{
var stack = new Stack<Tree>();
stack.Push(commit.Tree);
while (stack.Count != 0)
{
var tree = stack.Pop();
foreach (var entry in tree)
{
byte[] bytes;
switch (entry.TargetType)
{
case TreeEntryTargetType.Blob:
zipOutputStream.PutNextEntry(new ZipEntry(entry.Path));
var blob = (Blob)entry.Target;
bytes = blob.GetContentStream().ToBytes();
if (newline == null)
zipOutputStream.Write(bytes, 0, bytes.Length);
else
{
var encoding = FileHelper.DetectEncoding(bytes, CpToEncoding(commit.Encoding), _i18n.Value);
if (encoding == null)
zipOutputStream.Write(bytes, 0, bytes.Length);
else
{
bytes = FileHelper.ReplaceNewline(bytes, encoding, newline);
zipOutputStream.Write(bytes, 0, bytes.Length);
}
}
break;
case TreeEntryTargetType.Tree:
stack.Push((Tree)entry.Target);
break;
case TreeEntryTargetType.GitLink:
zipOutputStream.PutNextEntry(new ZipEntry(entry.Path + "/.gitsubmodule"));
bytes = Encoding.ASCII.GetBytes(entry.Target.Sha);
zipOutputStream.Write(bytes, 0, bytes.Length);
break;
}
}
}
zipOutputStream.SetComment(commit.Sha);
}
return filename;
}
protected void MakeZipFile(string name, string entryNamePrefix, int entries, int size, string comment)
{
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
using (IsolatedStorageFileStream fs = store.CreateFile(name))
{
using (ZipOutputStream zOut = new ZipOutputStream(fs))
{
zOut.SetComment(comment);
for (int i = 0; i < entries; ++i)
{
zOut.PutNextEntry(new ZipEntry(entryNamePrefix + (i + 1).ToString()));
AddKnownDataToEntry(zOut, size);
}
}
}
}
}
protected void MakeZipFile(string name, string[] names, int size, string comment)
{
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
using (IsolatedStorageFileStream fs = store.CreateFile(name))
{
using (ZipOutputStream zOut = new ZipOutputStream(fs))
{
zOut.SetComment(comment);
for (int i = 0; i < names.Length; ++i)
{
zOut.PutNextEntry(new ZipEntry(names[i]));
AddKnownDataToEntry(zOut, size);
}
zOut.Close();
}
fs.Close();
}
}
}
public void SetCommentOversize()
{
var ms = new MemoryStream();
var s = new ZipOutputStream(ms);
//s.SetComment(new String('A', 65536));
Assert.That(() => s.SetComment(new String('A', 65536)),
Throws.TypeOf<ArgumentOutOfRangeException>());
}
public void SetCommentOversize()
{
MemoryStream ms = new MemoryStream();
ZipOutputStream s = new ZipOutputStream(ms);
s.SetComment(new String('A', 65536));
}
protected void MakeZipFile(string name, string entryNamePrefix, int entries, int size, string comment)
{
using (FileStream fs = File.Create(name))
using (ZipOutputStream zOut = new ZipOutputStream(fs)) {
zOut.SetComment(comment);
for (int i = 0; i < entries; ++i) {
zOut.PutNextEntry(new ZipEntry(entryNamePrefix + (i + 1).ToString()));
AddKnownDataToEntry(zOut, size);
}
}
}
private void ZipDirectory(string zipfile, string folder, string comment, List<KeyValuePair<string, string>> filemap)
{
ICSharpCode.SharpZipLib.Zip.ZipConstants.DefaultCodePage = System.Text.Encoding.UTF8.CodePage;
ICSharpCode.SharpZipLib.Checksums.Crc32 crc = new ICSharpCode.SharpZipLib.Checksums.Crc32();
using (System.IO.FileStream ofs = new System.IO.FileStream(zipfile, System.IO.FileMode.Create, System.IO.FileAccess.Write, System.IO.FileShare.None))
using (ICSharpCode.SharpZipLib.Zip.ZipOutputStream zip = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(ofs))
{
try
{
zip.SetLevel(9);
if (!string.IsNullOrEmpty(comment))
zip.SetComment(comment);
int i = 0;
foreach (KeyValuePair<string, string> f in filemap)
{
if (Progress != null)
Progress(ProgressType.Compressing, f.Key, filemap.Count, i);
System.IO.FileInfo fi = new System.IO.FileInfo(f.Value);
ICSharpCode.SharpZipLib.Zip.ZipEntry ze = new ICSharpCode.SharpZipLib.Zip.ZipEntry(RelativeName(f.Key, folder).Replace('\\', '/'));
ze.DateTime = fi.LastWriteTime;
ze.Size = fi.Length;
zip.PutNextEntry(ze);
using (System.IO.FileStream fs = new System.IO.FileStream(fi.FullName, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.None))
Utility.CopyStream(fs, zip);
if (Progress != null)
Progress(ProgressType.Compressing, f.Key, filemap.Count, i++);
}
zip.Finish();
}
finally
{
try { zip.Close(); }
catch { }
}
}
}
private object createZip(Stream fileStream, string sourceDirectory, IStringFilter nf, IStringFilter df)
{
ZipEntryFactory entryFactory;
switch (ZipTime)
{
default:
case ZipTime.Now:
entryFactory = new ZipEntryFactory(DateTime.Now);
break;
case ZipTime.UtcNow:
entryFactory = new ZipEntryFactory(DateTime.UtcNow);
break;
case ZipTime.FileTime:
entryFactory = new ZipEntryFactory(ZipEntryFactory.TimeSetting.LastWriteTime);
break;
case ZipTime.UtcFileTime:
entryFactory = new ZipEntryFactory(ZipEntryFactory.TimeSetting.LastWriteTimeUtc);
break;
}
entryFactory.NameTransform = new ZipNameTransform(sourceDirectory);
entryFactory.IsUnicodeText = Unicode;
ProgressHandler progress = delegate(object x, ProgressEventArgs y) { Context.OnProgress(1, y.Name); };
using (ZipOutputStream zip = new ZipOutputStream(fileStream))
{
if (Comment!=null)
zip.SetComment(Context.TransformStr(Password, Transform));
if (Password != null)
zip.Password = Context.TransformStr(Password, Transform);
zip.SetLevel(Level);
return scanDir(sourceDirectory, new scanDirParams(zip, sourceDirectory, entryFactory, progress, nf, df));
}
}
public static void SignPackage(Stream input, X509Certificate2 certificate, Stream output, bool signWholeFile)
{
JarFile inputJar = null;
ZipOutputStream outputJar = null;
// Assume the certificate is valid for at least an hour.
DateTime timestamp = DateTime.Parse(certificate.GetEffectiveDateString()).AddHours(1);
inputJar = new JarFile(input); // Don't verify.
Stream outputStream = null;
if (signWholeFile)
{
outputStream = new MemoryStream();
}
else
{
outputStream = output;
}
outputJar = new ZipOutputStream(outputStream);
outputJar.SetComment(null);
outputJar.SetLevel(9);
JarEntry je;
Manifest manifest = addDigestsToManifest(inputJar);
// Everything else
copyFiles(manifest, inputJar, outputJar, timestamp);
// otacert
if (signWholeFile)
{
addOtacert(outputJar, certificate, timestamp, manifest);
}
var buffer = new MemoryStream();
// MANIFEST.MF
je = new JarEntry(JarFile.MANIFEST_NAME);
je.DateTime = timestamp;
manifest.Write(buffer);
je.Size = buffer.Length;
outputJar.PutNextEntry(je);
buffer.WriteTo(outputJar);
// CERT.SF
var signature = new MemoryStream();
je = new JarEntry(CERT_SF_NAME);
je.DateTime = timestamp;
buffer.SetLength(0);
writeSignatureFile(manifest, signature);
signature.WriteTo(buffer);
je.Size = buffer.Length;
outputJar.PutNextEntry(je);
buffer.WriteTo(outputJar);
// CERT.RSA
je = new JarEntry(CERT_RSA_NAME);
je.DateTime = timestamp;
buffer.SetLength(0);
writeSignatureBlock(signature, certificate, buffer);
je.Size = buffer.Length;
outputJar.PutNextEntry(je);
buffer.WriteTo(outputJar);
outputJar.Close();
outputJar = null;
if (signWholeFile)
{
signWholeOutputFile(((MemoryStream)outputStream).ToArray(),
output, certificate);
}
}
private void SaveBackground_DoWork(object sender, DoWorkEventArgs e)
{
try
{
string tmpdirectorypath = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "tmp") + System.IO.Path.DirectorySeparatorChar;
using (FileStream tempFileStream = new FileStream(ProjectSavePath, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
using (ZipOutputStream zipOutput = new ZipOutputStream(tempFileStream))
{
// Zip with highest compression.
zipOutput.SetLevel(9);
zipOutput.SetComment(ProjectInfo.FileVersion.ToString());
//Project Data
string projfilename = SaveProject(tmpdirectorypath);
using (FileStream fileStream = new FileStream(projfilename, FileMode.Open, FileAccess.Read, FileShare.Read))
{
// Read full stream to in-memory buffer.
byte[] buffer = new byte[fileStream.Length];
fileStream.Read(buffer, 0, buffer.Length);
// Create a new entry for the current file.
ZipEntry entry = new ZipEntry(System.IO.Path.GetFileName(projfilename));
entry.DateTime = DateTime.Now;
entry.Size = fileStream.Length;
entry.Comment = "Main";
fileStream.Close();
zipOutput.PutNextEntry(entry);
zipOutput.Write(buffer, 0, buffer.Length);
buffer = null;
}
//Thumbs
string[] thumbs = Directory.GetFiles(Thumbpath);
for (int i = 0; i < thumbs.Length; i++)
{
using (FileStream fileStream = new FileStream(thumbs[i], FileMode.Open, FileAccess.Read, FileShare.Read))
{
// Read full stream to in-memory buffer.
byte[] buffer = new byte[fileStream.Length];
fileStream.Read(buffer, 0, buffer.Length);
// Create a new entry for the current file.
ZipEntry entry = new ZipEntry(System.IO.Path.GetFileName(thumbs[i]));
entry.DateTime = DateTime.Now;
entry.Size = fileStream.Length;
entry.Comment = "Thumb";
fileStream.Close();
zipOutput.PutNextEntry(entry);
zipOutput.Write(buffer, 0, buffer.Length);
buffer = null;
}
}
zipOutput.Finish();
zipOutput.Flush();
zipOutput.Close();
}
}
Directory.Delete(tmpdirectorypath, true);
ProjectSaved = true;
e.Result = true;
}
catch (Exception ex)
{
e.Result = false;
ThreadException = ex;
}
}
protected void MakeZipFile(Stream storage, bool isOwner, string[] names, int size, string comment)
{
using (ZipOutputStream zOut = new ZipOutputStream(storage)) {
zOut.IsStreamOwner = isOwner;
zOut.SetComment(comment);
for (int i = 0; i < names.Length; ++i) {
zOut.PutNextEntry(new ZipEntry(names[i]));
AddKnownDataToEntry(zOut, size);
}
zOut.Close();
}
}
protected void MakeZipFile(string name, string[] names, int size, string comment)
{
using (FileStream fs = File.Create(name)) {
using (ZipOutputStream zOut = new ZipOutputStream(fs)) {
zOut.SetComment(comment);
for (int i = 0; i < names.Length; ++i) {
zOut.PutNextEntry(new ZipEntry(names[i]));
AddKnownDataToEntry(zOut, size);
}
zOut.Close();
}
fs.Close();
}
}
public void CommentTooLong()
{
MemoryStream ms = new MemoryStream();
ZipOutputStream s = new ZipOutputStream(ms);
s.SetComment(new String('A', 65536));
}
protected void MakeZipFile(Stream storage, bool isOwner,
string entryNamePrefix, int entries, int size, string comment)
{
using (ZipOutputStream zOut = new ZipOutputStream(storage)) {
zOut.IsStreamOwner = isOwner;
zOut.SetComment(comment);
for (int i = 0; i < entries; ++i) {
zOut.PutNextEntry(new ZipEntry(entryNamePrefix + (i + 1).ToString()));
AddKnownDataToEntry(zOut, size);
}
}
}
/// <summary>
/// Creates the zip file.
/// </summary>
protected override void ExecuteTask() {
ZipOutputStream zOutstream = null;
Log(Level.Info, "Zipping {0} files to '{1}'.",
ZipFileSets.FileCount, ZipFile.FullName);
try {
if (!Directory.Exists(ZipFile.DirectoryName)) {
Directory.CreateDirectory(ZipFile.DirectoryName);
}
// set encoding to use for filenames and comment
ZipConstants.DefaultCodePage = Encoding.CodePage;
zOutstream = new ZipOutputStream(ZipFile.Create());
// set compression level
zOutstream.SetLevel(ZipLevel);
// set comment
if (!String.IsNullOrEmpty(Comment)) {
zOutstream.SetComment(Comment);
}
foreach (ZipFileSet fileset in ZipFileSets) {
string basePath = fileset.BaseDirectory.FullName;
if (Path.GetPathRoot(basePath) != basePath) {
basePath = Path.GetDirectoryName(basePath + Path.DirectorySeparatorChar);
}
// add files to zip
foreach (string file in fileset.FileNames) {
// ensure file exists (in case "asis" was used)
if (!File.Exists(file)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"File '{0}' does not exist.", file), Location);
}
// the name of the zip entry
string entryName;
// determine name of the zip entry
if (!Flatten && file.StartsWith(basePath)) {
entryName = file.Substring(basePath.Length);
if (entryName.Length > 0 && entryName[0] == Path.DirectorySeparatorChar) {
entryName = entryName.Substring(1);
}
// remember that directory was added to zip file, so
// that we won't add it again later
string dir = Path.GetDirectoryName(file);
if (_addedDirs[dir] == null) {
_addedDirs[dir] = dir;
}
} else {
// flatten directory structure
entryName = Path.GetFileName(file);
}
// add prefix if specified
if (fileset.Prefix != null) {
entryName = fileset.Prefix + entryName;
}
// ensure directory separators are understood on linux
if (Path.DirectorySeparatorChar == '\\') {
entryName = entryName.Replace(@"\", "/");
}
// perform duplicate checking
if (_fileEntries.ContainsKey(entryName)) {
switch (DuplicateHandling) {
case DuplicateHandling.Add:
break;
case DuplicateHandling.Fail:
throw new BuildException(string.Format(
CultureInfo.InvariantCulture,
"Duplicate file '{0}' was found.",
entryName), Location.UnknownLocation);
case DuplicateHandling.Preserve:
// skip current entry
continue;
default:
throw new BuildException(string.Format(
CultureInfo.InvariantCulture,
"Duplicate value '{0}' is not supported.",
DuplicateHandling.ToString()),
Location.UnknownLocation);
}
}
// create zip entry
ZipEntry entry = new ZipEntry(entryName);
// store entry (to allow for duplicate checking)
_fileEntries[entryName] = null;
// set date/time stamp on zip entry
if (Stamp != DateTime.MinValue) {
entry.DateTime = Stamp;
} else {
entry.DateTime = File.GetLastWriteTime(file);
}
// write file content to stream in small chuncks
using (FileStream fs = File.OpenRead(file)) {
// set size for backward compatibility with older unzip
entry.Size = fs.Length;
Log(Level.Verbose, "Adding {0}.", entryName);
// write file to zip file
zOutstream.PutNextEntry(entry);
byte[] buffer = new byte[50000];
while (true) {
int bytesRead = fs.Read(buffer, 0, buffer.Length);
if (bytesRead == 0)
break;
zOutstream.Write(buffer, 0, bytesRead);
}
}
}
// add (possibly empty) directories to zip
if (IncludeEmptyDirs) {
foreach (string directory in fileset.DirectoryNames) {
// skip directories that were already added when the
// files were added
if (_addedDirs[directory] != null) {
continue;
}
// skip directories that are not located beneath the base
// directory
if (!directory.StartsWith(basePath) || directory.Length <= basePath.Length) {
continue;
}
// determine zip entry name
string entryName = directory.Substring(basePath.Length + 1);
// add prefix if specified
if (fileset.Prefix != null) {
entryName = fileset.Prefix + entryName;
}
// ensure directory separators are understood on linux
if (Path.DirectorySeparatorChar == '\\') {
entryName = entryName.Replace(@"\", "/");
}
if (!entryName.EndsWith("/")) {
// trailing directory signals to #ziplib that we're
// dealing with directory entry
entryName += "/";
}
// create directory entry
ZipEntry entry = new ZipEntry(entryName);
// set size for backward compatibility with older unzip
entry.Size = 0L;
// write directory to zip file
zOutstream.PutNextEntry(entry);
}
}
}
zOutstream.Close();
zOutstream.Finish();
} catch (Exception ex) {
// close the zip output stream
if (zOutstream != null) {
zOutstream.Close();
}
// delete the (possibly corrupt) zip file
if (ZipFile.Exists) {
ZipFile.Delete();
}
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Zip file '{0}' could not be created.", ZipFile.FullName),
Location, ex);
} finally {
CleanUp();
}
}
/// <summary>
/// Packs the specified dictionary.
/// </summary>
/// <param name="dictionary">The dictionary.</param>
/// <param name="archivePath">The archive path.</param>
/// <returns>The full path (including the filename) to the archive or String.Empty of the process was interrupted.</returns>
/// <remarks>Documented by Dev03, 2007-09-10</remarks>
public string Pack(IDictionary dictionary, string archivePath)
{
string dictionaryPath = ((XML.XmlDictionary)dictionary).Path;
string fullArchivePath = String.Empty;
if ((Path.GetFileName(archivePath).Length == 0) || (Path.GetExtension(archivePath).Length == 0))
{
fullArchivePath = Path.Combine(archivePath, Path.GetRandomFileName() + Resources.DICTIONARY_ARCHIVE_EXTENSION);
}
else
{
fullArchivePath = archivePath;
}
FileStream target = File.Create(fullArchivePath);
//ZipConstants.DefaultCodePage = Encoding.Unicode.CodePage; //this may possibly mean that we are not Zip compatible anymore
ZipOutputStream zip_stream = new ZipOutputStream(target);
// set compression level 0(low) to 9 (high)
zip_stream.SetLevel(5);
// write the old category id to the header for backward compatibility
zip_stream.SetComment(String.Format(Resources.PACKER_ARCHIVE_HEADER_COMMENT_PACK, dictionary.Category.OldId));
string dirPath = Path.GetDirectoryName(dictionaryPath);
Directory.SetCurrentDirectory(dirPath);
List<string> resourceList = dictionary.GetResources();
resourceList.Add(dictionaryPath); //add the dictionary
if (!ReportProgressUpdate(0)) return String.Empty;
for (int i = 0; i < resourceList.Count; i++)
{
string fullPath, relPath;
if (Path.IsPathRooted(resourceList[i]))
{
if (resourceList[i].StartsWith(dirPath))
{
relPath = resourceList[i].Replace(dirPath, String.Empty).Trim(new char[] { Path.DirectorySeparatorChar, ' ' });
fullPath = resourceList[i];
}
else
{
continue;
}
}
else
{
try
{
relPath = resourceList[i];
fullPath = Path.GetFullPath(resourceList[i]);
}
catch
{
continue;
}
}
if (!File.Exists(fullPath))
continue;
FileStream fs = new FileStream(fullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
// allocate file buffer
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, buffer.Length);
// writing zip entry and data
ZipEntry entry = new ZipEntry(relPath);
zip_stream.PutNextEntry(entry);
zip_stream.Write(buffer, 0, buffer.Length);
zip_stream.CloseEntry();
fs.Close();
int progress = (int)Math.Floor(100.0 * (i + 1) / resourceList.Count);
if (!ReportProgressUpdate(progress)) return String.Empty;
}
if (!ReportProgressUpdate(100)) return String.Empty;
zip_stream.Finish();
zip_stream.Close();
target.Close();
return fullArchivePath;
}
private bool ZipFiles() {
Crc32 crc = new Crc32();
ZipOutputStream zs = null;
try {
string zipFileName = Path.GetFullPath(_zipFileName);
string outputDirectory = Path.GetDirectoryName(zipFileName);
string baseDirectory = null;
if (String.IsNullOrEmpty(_workingDirectory) == false) {
baseDirectory = Path.GetFullPath(_workingDirectory);
}
if (Directory.Exists(outputDirectory) == false) {
Directory.CreateDirectory(outputDirectory);
}
Log.LogMessage("Creating zip file \"{0}\".", zipFileName);
using (zs = new ZipOutputStream(File.Create(zipFileName))) {
// make sure level in range
_zipLevel = Math.Max(0, _zipLevel);
_zipLevel = Math.Min(9, _zipLevel);
zs.SetLevel(_zipLevel);
if (!String.IsNullOrEmpty(_comment)) {
zs.SetComment(_comment);
}
byte[] buffer = new byte[32768];
// add files to zip
foreach (ITaskItem fileItem in _files) {
string name = Path.GetFullPath(fileItem.ItemSpec);
FileInfo file = new FileInfo(name);
if (!file.Exists) {
Log.LogWarning("File Not Found: {0}.", file.FullName);
continue;
}
// clean up name
if (_flatten) {
name = file.Name;
}
else if (!String.IsNullOrEmpty(baseDirectory) &&
name.StartsWith(baseDirectory, StringComparison.OrdinalIgnoreCase)) {
name = name.Substring(baseDirectory.Length);
}
name = ZipEntry.CleanName(name, true);
ZipEntry entry = new ZipEntry(name);
entry.DateTime = file.LastWriteTime;
entry.Size = file.Length;
using (FileStream fs = file.OpenRead()) {
crc.Reset();
long len = fs.Length;
while (len > 0) {
int readSoFar = fs.Read(buffer, 0, buffer.Length);
crc.Update(buffer, 0, readSoFar);
len -= readSoFar;
}
entry.Crc = crc.Value;
zs.PutNextEntry(entry);
len = fs.Length;
fs.Seek(0, SeekOrigin.Begin);
while (len > 0) {
int readSoFar = fs.Read(buffer, 0, buffer.Length);
zs.Write(buffer, 0, readSoFar);
len -= readSoFar;
}
}
Log.LogMessage(" added \"{0}\".", name);
}
zs.Finish();
}
Log.LogMessage("Created zip file \"{0}\" successfully.", _zipFileName);
return true;
}
catch (Exception exc) {
Log.LogErrorFromException(exc);
return false;
}
finally {
if (zs != null) {
zs.Close();
}
}
}
