func packFile(srcFile string, recPath string, zw *zip.Writer, fi os.FileInfo) (err error) { if fi.IsDir() { // Create zip header fh := new(zip.FileHeader) fh.Name = recPath + "/" fh.UncompressedSize = 0 _, err = zw.CreateHeader(fh) } else { // Create zip header fh := new(zip.FileHeader) fh.Name = recPath fh.UncompressedSize = uint32(fi.Size()) fh.SetMode(fi.Mode()) var fw io.Writer fw, err = zw.CreateHeader(fh) if err != nil { return err } var f *os.File f, err = os.Open(srcFile) if err != nil { return err } _, err = io.Copy(fw, f) } return err }
func addKeysToArchive(zipWriter *zip.Writer, newKeyStore *trustmanager.KeyFileStore, subDir string) error { // List all files but no symlinks for _, relKeyPath := range newKeyStore.ListFiles(false) { fullKeyPath := filepath.Join(newKeyStore.BaseDir(), relKeyPath) fi, err := os.Stat(fullKeyPath) if err != nil { return err } infoHeader, err := zip.FileInfoHeader(fi) if err != nil { return err } infoHeader.Name = filepath.Join(subDir, relKeyPath) zipFileEntryWriter, err := zipWriter.CreateHeader(infoHeader) if err != nil { return err } fileContents, err := ioutil.ReadFile(fullKeyPath) if err != nil { return err } if _, err = zipFileEntryWriter.Write(fileContents); err != nil { return err } } return nil }
// Deal with file func zipFile(srcFile string, recPath string, zw *zip.Writer, fi os.FileInfo) { if fi.IsDir() { // Create zip header fh := new(zip.FileHeader) fh.Name = recPath + "/" fh.UncompressedSize = 0 _, err := zw.CreateHeader(fh) handleError(err) } else { // Create zip header fh := new(zip.FileHeader) fh.Name = recPath fh.UncompressedSize = uint32(fi.Size()) fw, err := zw.CreateHeader(fh) handleError(err) // Read file data buf := make([]byte, fi.Size()) f, err := os.Open(srcFile) handleError(err) _, err = f.Read(buf) handleError(err) // Write file data to zip _, err = fw.Write(buf) handleError(err) } }
// Writes this tree to the given zip file, returning an error on failure. func (t Stream) ToZip(w *zip.Writer) error { for blob := range t { hdr, err := zip.FileInfoHeader(blob) if err != nil { return err } writer, err := w.CreateHeader(hdr) if err != nil { return err } if blob.Contents() != nil { _, err := io.Copy(writer, blob.Contents()) if err != nil { return err } } if blob.Error() != nil { return blob.Error() } } w.Close() return nil }
func writeFile2Zip(zw *zip.Writer, path string, name string) error { file, err := os.Open(path + name) if err != nil { return err } defer file.Close() info, err := file.Stat() if err != nil { return err } header, err := zip.FileInfoHeader(info) if err != nil { return err } header.Name = name writer, err := zw.CreateHeader(header) if err != nil { return err } _, err = io.Copy(writer, file) return err }
func addHandlerToZip(w *zip.Writer, bf baofile.Baofile) error { path := "lambda/handler_example.js" f, err := os.Open(path) if err != nil { return err } info, err := f.Stat() if err != nil { return err } header, err := zip.FileInfoHeader(info) if err != nil { return err } wr, err := w.CreateHeader(header) if err != nil { return err } fileBytes, err := ioutil.ReadFile(path) if err != nil { return err } handlerTemplate := string(fileBytes) t := template.Must(template.New("handler").Parse(handlerTemplate)) err = t.Execute(wr, bf) if err != nil { return err } return nil }
func writeFileToZip(zipper *zip.Writer, filename string) error { file, err := os.Open(filename) if err != nil { return err } defer file.Close() info, err := file.Stat() if err != nil { return err } header, err := zip.FileInfoHeader(info) if err != nil { return err } header.Name = helper.SanitizedName(filename) writer, err := zipper.CreateHeader(header) if err != nil { return err } _, err = io.Copy(writer, file) return err }
func foliazipdir(q *Context, zf *zip.Writer, fdir, subdir string) (ok bool) { dir := filepath.Join(fdir, subdir) files, err := ioutil.ReadDir(dir) if foliaErr(q, err) { return false } for _, file := range files { fname := path.Join(subdir, file.Name()) // in zip alleen forward slashes toegestaan if file.IsDir() { if !foliazipdir(q, zf, fdir, fname) { return false } } else { data, err := ioutil.ReadFile(filepath.Join(fdir, fname)) if foliaErr(q, err) { return false } fh, err := zip.FileInfoHeader(file) if foliaErr(q, err) { return false } fh.Name = fname f, err := zf.CreateHeader(fh) if foliaErr(q, err) { return false } _, err = f.Write(data) if foliaErr(q, err) { return false } } } return true }
func addZip(filename, buildDir string, zipWriter *zip.Writer) error { zipfile, err := os.Open(filename) if err != nil { return err } defer zipfile.Close() info, err := zipfile.Stat() if err != nil { return err } header, err := zip.FileInfoHeader(info) if err != nil { return err } r := regexp.MustCompile(buildDir + "/") header.Name = r.ReplaceAllString(filename, "") writer, err := zipWriter.CreateHeader(header) if err != nil { return err } _, err = io.Copy(writer, zipfile) return nil }
func addFileToZip(zipWriter *zip.Writer, fi os.FileInfo, srcPath string) error { fh, err := zip.FileInfoHeader(fi) if err != nil { return err } fh.Method = zip.Deflate destFile, err := zipWriter.CreateHeader(fh) if err != nil { return err } srcFile, err := os.Open(srcPath) if err != nil { return err } defer srcFile.Close() ba, err := ioutil.ReadAll(srcFile) if err != nil { return err } //_, err = io.Copy(destFile, srcFile) _, err = destFile.Write(ba) return err }
func addFileToZIP(zw *zip.Writer, item ArchiveItem) (err error) { binfo, err := os.Stat(item.FileSystemPath) if err != nil { return } header, err := zip.FileInfoHeader(binfo) if err != nil { return } header.Method = zip.Deflate //always use forward slashes even on Windows header.Name = strings.Replace(item.ArchivePath, "\\", "/", -1) w, err := zw.CreateHeader(header) if err != nil { zw.Close() return } bf, err := os.Open(item.FileSystemPath) if err != nil { return } defer bf.Close() _, err = io.Copy(w, bf) return }
func addKeysToArchive(zipWriter *zip.Writer, newKeyStore *trustmanager.KeyFileStore, tempBaseDir string) error { // List all files but no symlinks for _, fullKeyPath := range newKeyStore.ListFiles(false) { relKeyPath := strings.TrimPrefix(fullKeyPath, tempBaseDir) relKeyPath = strings.TrimPrefix(relKeyPath, string(filepath.Separator)) fi, err := os.Stat(fullKeyPath) if err != nil { return err } infoHeader, err := zip.FileInfoHeader(fi) if err != nil { return err } infoHeader.Name = relKeyPath zipFileEntryWriter, err := zipWriter.CreateHeader(infoHeader) if err != nil { return err } fileContents, err := ioutil.ReadFile(fullKeyPath) if err != nil { return err } if _, err = zipFileEntryWriter.Write(fileContents); err != nil { return err } } return nil }
func addFileToZip(w *zip.Writer, path string, newname string) error { f, err := os.Open(path) if err != nil { return err } info, err := f.Stat() if err != nil { return err } header, err := zip.FileInfoHeader(info) if err != nil { return err } if newname != "" { header.Name = newname } wr, err := w.CreateHeader(header) if err != nil { return err } fileBytes, err := ioutil.ReadFile(path) if err != nil { return err } _, err = wr.Write(fileBytes) if err != nil { return err } return nil }
func addZipEntry(zw *zip.Writer, f filetesting.Entry) { h := &zip.FileHeader{ Name: f.GetPath(), // Don't bother compressing - the contents are so small that // it will just slow things down for no particular benefit. Method: zip.Store, } contents := "" switch f := f.(type) { case filetesting.Dir: h.SetMode(os.ModeDir | 0755) case filetesting.File: h.SetMode(f.Perm) contents = f.Data case filetesting.Symlink: h.SetMode(os.ModeSymlink | 0777) contents = f.Link } w, err := zw.CreateHeader(h) if err != nil { panic(err) } if contents != "" { if _, err := w.Write([]byte(contents)); err != nil { panic(err) } } }
// 逐个文件,写入zip包 // zipper *zip.Writer:要写入的zip包的zip.Writer // includeFileName string:本次写入的文件的全路径+名字 func writeFileToZip(zipper *zip.Writer, includeFileName string) error { //打开待写入文件 includeFile, err := os.Open(includeFileName) if err != nil { return err } defer includeFile.Close() //获取文件描述 includeFileInfo, err := includeFile.Stat() if err != nil { return err } //zip.FileInfoHeader zipFileHeader, err := zip.FileInfoHeader(includeFileInfo) if err != nil { return err } //修改文件描述的Header,截断路径,只保留文件名 //否则,解压的时候,可能按压缩进来时候的文件路径来解压,解压回到原来的位置,而不是当前目录 zipFileHeader.Name = path.Base(includeFileName) //用zip.FileInfoHeader,创建zip包内的一个项,并获得io.Writer,准备写入文件 zipFileWriter, err := zipper.CreateHeader(zipFileHeader) if err != nil { return err } //写入本次的文件 _, err = io.Copy(zipFileWriter, includeFile) return err }
func addKeysToArchive(zipWriter *zip.Writer, newKeyStore *trustmanager.KeyFileStore) error { for _, relKeyPath := range newKeyStore.ListFiles() { fullKeyPath := filepath.Join(newKeyStore.BaseDir(), relKeyPath) fi, err := os.Lstat(fullKeyPath) if err != nil { return err } infoHeader, err := zip.FileInfoHeader(fi) if err != nil { return err } infoHeader.Name = relKeyPath zipFileEntryWriter, err := zipWriter.CreateHeader(infoHeader) if err != nil { return err } fileContents, err := ioutil.ReadFile(fullKeyPath) if err != nil { return err } if _, err = zipFileEntryWriter.Write(fileContents); err != nil { return err } } return nil }
func addKeysToArchive(zipWriter *zip.Writer, newKeyStore *trustmanager.KeyFileStore, subDir string) error { for _, relKeyPath := range newKeyStore.ListFiles(true) { fullKeyPath := filepath.Join(newKeyStore.BaseDir(), relKeyPath) fi, err := os.Lstat(fullKeyPath) if err != nil { return err } infoHeader, err := zip.FileInfoHeader(fi) if err != nil { return err } infoHeader.Name = filepath.Join(subDir, relKeyPath) // Is this a symlink? If so, encode properly in the zip file. if (fi.Mode() & os.ModeSymlink) != 0 { infoHeader.CreatorVersion = zipMadeByUNIX infoHeader.ExternalAttrs = zipSymlinkAttr zipFileEntryWriter, err := zipWriter.CreateHeader(infoHeader) if err != nil { return err } target, err := os.Readlink(fullKeyPath) if err != nil { return err } // Write relative path if _, err = zipFileEntryWriter.Write([]byte(target)); err != nil { return err } } else { zipFileEntryWriter, err := zipWriter.CreateHeader(infoHeader) if err != nil { return err } fileContents, err := ioutil.ReadFile(fullKeyPath) if err != nil { return err } if _, err = zipFileEntryWriter.Write(fileContents); err != nil { return err } } } return nil }
/* Helper. Recursively zip the contents of a directory tree using the zip.Writer. Filters so it only includes .rel files Note: this will not work if there are symbolic links in the src directory tree. (because Readdir does not follow links.) */ func zipSrcDirTree2(w *zip.Writer, directoryPath string, relativeDirName string) (err error) { var dir *os.File var filesInDir []os.FileInfo dir, err = gos.Open(directoryPath) filesInDir, err = dir.Readdir(0) if err != nil { return } err = dir.Close() for _, fileInfo := range filesInDir { if fileInfo.IsDir() { subItemPath := directoryPath + "/" + fileInfo.Name() subItemRelativePath := relativeDirName + "/" + fileInfo.Name() err = zipSrcDirTree2(w, subItemPath, subItemRelativePath) if err != nil { return } } else { // plain old file to be added. if strings.HasSuffix(fileInfo.Name(), ".rel") || strings.HasSuffix(fileInfo.Name(), ".txt") || strings.HasSuffix(fileInfo.Name(), ".html") || strings.HasSuffix(fileInfo.Name(), ".htm") || strings.HasSuffix(fileInfo.Name(), ".css") { subItemPath := directoryPath + "/" + fileInfo.Name() subItemRelativePath := relativeDirName + "/" + fileInfo.Name() var fh *zip.FileHeader fh, err = zip.FileInfoHeader(fileInfo) if err != nil { return } fh.Name = subItemRelativePath var zw io.Writer zw, err = w.CreateHeader(fh) if err != nil { return } var f *os.File f, err = gos.Open(subItemPath) if err != nil { return } _, err = io.Copy(zw, f) err = f.Close() if err != nil { return } } } } return }
func addFileToZIP(zw *zip.Writer, item ArchiveItem) error { //fmt.Printf("Adding %s\n", item.FileSystemPath) binfo, err := os.Stat(item.FileSystemPath) if err != nil { return err } if binfo.IsDir() { header, err := zip.FileInfoHeader(binfo) if err != nil { return err } header.Method = zip.Deflate header.Name = item.ArchivePath _, err = zw.CreateHeader(header) if err != nil { return err } file, err := os.Open(item.FileSystemPath) if err != nil { return err } fis, err := file.Readdir(0) for _, fi := range fis { err = addFileToZIP(zw, ArchiveItem{filepath.Join(item.FileSystemPath, fi.Name()), filepath.Join(item.ArchivePath, fi.Name()), nil}) if err != nil { return err } } } else { header, err := zip.FileInfoHeader(binfo) if err != nil { return err } header.Method = zip.Deflate header.Name = item.ArchivePath w, err := zw.CreateHeader(header) if err != nil { return err } bf, err := os.Open(item.FileSystemPath) if err != nil { return err } defer bf.Close() _, err = io.Copy(w, bf) if err != nil { return err } } return err }
func createZipSymlinkEntry(archive *zip.Writer, fh *zip.FileHeader) error { fw, err := archive.CreateHeader(fh) if err != nil { return err } link, err := os.Readlink(fh.Name) if err != nil { return err } _, err = io.WriteString(fw, link) return err }
func addZipFileMust(w *zip.Writer, path string) { fi, err := os.Stat(path) fataliferr(err) fih, err := zip.FileInfoHeader(fi) fataliferr(err) fih.Name = filepath.Base(path) d, err := ioutil.ReadFile(path) fataliferr(err) f, err := w.CreateHeader(fih) fataliferr(err) _, err = f.Write(d) fataliferr(err) // no need to close f. It's implicitly closed by the next Create(), CreateHeader() or Close() call }
// CreateNW creates a node-webkit .nw file func (p Package) CreateNW(zw *zip.Writer, templates Templates, myapp io.Reader, includes string) error { // Add in a couple of package defaults p.Main = "index.html" p.EnvVar = nw.EnvVar if w, err := zw.Create("package.json"); err != nil { return err } else { if _, err := p.writeJsonTo(w); err != nil { return err } } filenameTemplates := map[string]string{ "index.html": templates.IndexHtml, "client.js": templates.ClientJs, "script.js": templates.ScriptJs} for filename, str := range filenameTemplates { if w, err := zw.Create(filename); err != nil { return err } else { if t, err := template.New(filename).Parse(str); err != nil { return err } else { if err := t.Execute(w, p); err != nil { return err } } } } if includes != "" { if err := copyIncludes(zw, includes); err != nil { return err } } binHeader := zip.FileHeader{Name: p.Bin} binHeader.SetMode(0755) // Make it executable if w, err := zw.CreateHeader(&binHeader); err != nil { return err } else { if _, err := io.Copy(w, myapp); err != nil { return err } } return nil }
func zipEntries(readers map[string]entryReader, out *zip.Writer) error { defer trace.End(trace.Begin("")) defer out.Close() defer out.Flush() for name, r := range readers { log.Infof("Collecting log with reader %s(%#v)", name, r) e, err := r.open() if err != nil { log.Warningf("error reading %s(%s): %s\n", name, r, err) continue } sz := e.Size() header := &zip.FileHeader{ Name: name, Method: zip.Deflate, } header.SetModTime(time.Now()) header.SetMode(0644) if sz > uint32max { header.UncompressedSize = uint32max } else { header.UncompressedSize = uint32(e.Size()) } w, err := out.CreateHeader(header) if err != nil { log.Errorf("Failed to create Zip writer for %s: %s", header.Name, err) continue } log.Infof("%s has size %d", header.Name, sz) // be explicit about the number of bytes to copy as the log files will likely // be written to during this exercise _, err = io.CopyN(w, e, sz) _ = e.Close() if err != nil { log.Errorf("Failed to write content for %s: %s", header.Name, err) continue } log.Infof("Wrote %d bytes to %s", sz, header.Name) } return nil }
func addZipDataMust(zw *zip.Writer, path string, d []byte, zipName string) { fmt.Printf("adding data (%d bytes) as '%s'\n", len(d), zipName) fi, err := os.Stat(path) fataliferr(err) fih, err := zip.FileInfoHeader(fi) fataliferr(err) fih.Name = zipName fih.Method = zip.Store fw, err := zw.CreateHeader(fih) fataliferr(err) _, err = fw.Write(d) fataliferr(err) // fw is just a io.Writer so we can't Close() it. It's not necessary as // it's implicitly closed by the next Create(), CreateHeader() // or Close() call on zip.Writer }
func zipAdd(w *zip.Writer, name string, path string) error { in, e := os.Open(path) if e != nil { return e } head := &zip.FileHeader{Name: name} head.SetModTime(time.Now()) f, e := w.CreateHeader(head) if e != nil { return e } if _, e := io.Copy(f, bufio.NewReader(in)); e != nil { return e } return nil }
func addZipFileMust(w *zip.Writer, path string) { fi, err := os.Stat(path) fataliferr(err) fih, err := zip.FileInfoHeader(fi) fataliferr(err) fih.Name = filepath.Base(path) fih.Method = zip.Deflate d, err := ioutil.ReadFile(path) fataliferr(err) fw, err := w.CreateHeader(fih) fataliferr(err) _, err = fw.Write(d) fataliferr(err) // fw is just a io.Writer so we can't Close() it. It's not necessary as // it's implicitly closed by the next Create(), CreateHeader() // or Close() call on zip.Writer }
// packFile packs a file or directory to zip.Writer. func packFile(srcFile string, recPath string, zw *zip.Writer, fi os.FileInfo) error { if fi.IsDir() { fh, err := zip.FileInfoHeader(fi) if err != nil { return err } fh.Name = recPath + "/" if _, err = zw.CreateHeader(fh); err != nil { return err } } else { fh, err := zip.FileInfoHeader(fi) if err != nil { return err } fh.Name = recPath fh.Method = zip.Deflate fw, err := zw.CreateHeader(fh) if err != nil { return err } if fi.Mode()&os.ModeSymlink != 0 { target, err := os.Readlink(srcFile) if err != nil { return err } if _, err = fw.Write([]byte(target)); err != nil { return err } } else { f, err := os.Open(srcFile) if err != nil { return err } defer f.Close() if _, err = io.Copy(fw, f); err != nil { return err } } } return nil }
func addZipFileMust(zw *zip.Writer, path, zipName string) { fi, err := os.Stat(path) fataliferr(err) fmt.Printf("adding '%s' (%d bytes) as '%s'\n", path, fi.Size(), zipName) fih, err := zip.FileInfoHeader(fi) fataliferr(err) fih.Name = zipName fih.Method = zip.Deflate d, err := ioutil.ReadFile(path) fataliferr(err) fw, err := zw.CreateHeader(fih) fataliferr(err) _, err = fw.Write(d) fataliferr(err) // fw is just a io.Writer so we can't Close() it. It's not necessary as // it's implicitly closed by the next Create(), CreateHeader() // or Close() call on zip.Writer }
func createZipFileEntry(archive *zip.Writer, fh *zip.FileHeader) error { fh.Method = zip.Deflate fw, err := archive.CreateHeader(fh) if err != nil { return err } file, err := os.Open(fh.Name) if err != nil { return err } _, err = io.Copy(fw, file) file.Close() if err != nil { return err } return nil }
// ZipWalker returns a filepath.WalkFunc that adds every filesystem node // to the given *zip.Writer. func ZipWalker(zw *zip.Writer) filepath.WalkFunc { var base string return func(path string, info os.FileInfo, err error) error { if base == "" { base = path } header, err := zip.FileInfoHeader(info) if err != nil { return err } if header.Name, err = filepath.Rel(base, path); err != nil { return err } else if info.IsDir() { header.Name = header.Name + string(filepath.Separator) } else { header.Method = zip.Deflate } w, err := zw.CreateHeader(header) if err != nil { return err } if info.IsDir() { return nil } f, err := os.Open(path) if err != nil { return err } _, err = io.Copy(w, f) f.Close() return err } }