// StreamFile streams a file or directory entry into StreamArchive. func (s *StreamArchive) StreamFile(relPath string, fi os.FileInfo, data []byte) error { if fi.IsDir() { fh, err := tar.FileInfoHeader(fi, "") if err != nil { return err } fh.Name = relPath + "/" if err = s.Writer.WriteHeader(fh); err != nil { return err } } else { target := "" if fi.Mode()&os.ModeSymlink != 0 { target = string(data) } fh, err := tar.FileInfoHeader(fi, target) if err != nil { return err } fh.Name = filepath.Join(relPath, fi.Name()) if err = s.Writer.WriteHeader(fh); err != nil { return err } if _, err = s.Writer.Write(data); err != nil { return err } } return nil }
func addFileToTar(zw *tar.Writer, item someutils.ArchiveItem, isVerbose bool, outPipe io.Writer) error { if isVerbose { fmt.Fprintf(outPipe, "Adding %s\n", item.FileSystemPath) } binfo, err := os.Stat(item.FileSystemPath) if err != nil { return err } if binfo.IsDir() { header, err := tar.FileInfoHeader(binfo, "") if err != nil { return err } header.Name = item.ArchivePath err = zw.WriteHeader(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 = addFileToTar(zw, someutils.ArchiveItem{filepath.Join(item.FileSystemPath, fi.Name()), filepath.Join(item.ArchivePath, fi.Name()), nil}, isVerbose, outPipe) if err != nil { return err } } } else { header, err := tar.FileInfoHeader(binfo, "") if err != nil { return err } header.Name = item.ArchivePath err = zw.WriteHeader(header) if err != nil { return err } bf, err := os.Open(item.FileSystemPath) if err != nil { return err } defer bf.Close() _, err = io.Copy(zw, bf) if err != nil { return err } err = zw.Flush() if err != nil { return err } err = bf.Close() if err != nil { return err } } return err }
func addDir(writer *tar.Writer, dirpath string) error { dir, err := os.Open(dirpath) if err != nil { return err } defer dir.Close() fi, err := dir.Stat() if err != nil { return err } header, err := tar.FileInfoHeader(fi, "") if err != nil { return err } header.Name = dirpath err = writer.WriteHeader(header) if err != nil { return err } fis, err := dir.Readdir(0) if err != nil { return err } for _, fi := range fis { if fi.IsDir() { err = addDir(writer, path.Join(dirpath, fi.Name())) } else { err = addFile(writer, path.Join(dirpath, fi.Name())) } if err != nil { return err } } return nil }
func writeFileToTarWriter(tarWriter *tar.Writer, info os.FileInfo, absoluteFilePath, overwriteFileName string, isOnlyFile bool) { hdr, err := tar.FileInfoHeader(info, "") CheckError(err) if overwriteFileName != "" { hdr.Name = overwriteFileName } if hdr.Xattrs == nil { hdr.Xattrs = map[string]string{} } hdr.Xattrs["SIZE"] = fmt.Sprintf("%d", info.Size()) if isOnlyFile { hdr.Xattrs["SINGLE_FILE_ONLY"] = "1" } err = tarWriter.WriteHeader(hdr) CheckError(err) if !info.IsDir() { file, err := os.Open(absoluteFilePath) CheckError(err) defer file.Close() _, err = io.Copy(tarWriter, file) CheckError(err) } }
func createTarArchive(files []string, output io.WriteCloser) error { archive := tar.NewWriter(output) defer archive.Close() for _, path := range files { file, err := os.Open(path) if err != nil { return fmt.Errorf("Unable to read file %s: %s", path, err) } defer file.Close() fi, err := file.Stat() if err != nil { return fmt.Errorf("Unable to get fileinfo for %s: %s", path, err) } header, err := tar.FileInfoHeader(fi, path) if err != nil { return fmt.Errorf("Failed to create tar header for %s: %s", path, err) } if err := archive.WriteHeader(header); err != nil { return fmt.Errorf("Failed to write tar header for %s: %s", path, err) } if _, err := io.Copy(archive, file); err != nil { return fmt.Errorf("Failed to copy %s data to archive: %s", path, err) } } return nil }
func (wft *tarWalk) compress(name, fpath string, fi os.FileInfo) (bool, error) { isSym := fi.Mode()&os.ModeSymlink > 0 link := "" if isSym { link, _ = os.Readlink(fpath) } hdr, err := tar.FileInfoHeader(fi, link) if err != nil { return false, err } hdr.Name = name tw := wft.tw err = tw.WriteHeader(hdr) if err != nil { return false, err } if isSym == false { fr, err := os.Open(fpath) if err != nil { return false, err } defer fr.Close() _, err = io.Copy(tw, fr) if err != nil { return false, err } tw.Flush() } return true, nil }
func (t *tarRenderer) Walk(path string, finfo os.FileInfo, err error) error { if err != nil { return err } fh, err := tar.FileInfoHeader(finfo, "") if err != nil { return err } fh.Name = "download/" + path err = t.w.WriteHeader(fh) if err != nil { return err } if finfo.IsDir() { return nil } f, err := os.Open(filepath.Join(t.root, path)) if err != nil { return err } defer f.Close() _, err = io.Copy(t.w, f) return err }
func WriteToTar(tarWriter *tar.Writer, file *TarFile) error { hdr, err := tar.FileInfoHeader(file.Info, "") if err != nil { return fmt.Errorf("Unable to get tar FileInfoHeader of tar file '%s', error: %s", file.FileName, err.Error()) } hdr.Name = file.FileName if hdr.Xattrs == nil { hdr.Xattrs = map[string]string{} } hdr.Xattrs["SIZE"] = fmt.Sprintf("%d", file.Info.Size()) if file.IsOnlyFile { hdr.Xattrs["SINGLE_FILE_ONLY"] = "1" } err = tarWriter.WriteHeader(hdr) if err != nil { return fmt.Errorf("Unable to write tar header for file '%s', error: %s", file.FileName, err.Error()) } if !file.HasContent() { return nil } defer file.ContentReadCloser.Close() _, err = io_throttler.CopyThrottled(io_throttler.DefaultIOThrottlingBandwidth, tarWriter, file.ContentReadCloser) return err }
func (ctx *runContext) createTarArchive(fd *os.File, dir string) error { tarFd := tar.NewWriter(fd) defer tarFd.Close() err := filepath.Walk(dir, func(name string, info os.FileInfo, err error) error { if err != nil { return errgo.Mask(err, errgo.Any) } if info.IsDir() { return nil } tarHeader, err := tar.FileInfoHeader(info, name) if err != nil { return fmt.Errorf("fail to build tar header: %v", err) } err = tarFd.WriteHeader(tarHeader) if err != nil { return fmt.Errorf("fail to write tar header: %v", err) } fileFd, err := os.OpenFile(name, os.O_RDONLY, 0600) if err != nil { return errgo.Mask(err, errgo.Any) } _, err = stdio.Copy(tarFd, fileFd) if err != nil { return errgo.Mask(err, errgo.Any) } return nil }) if err != nil { return errgo.Mask(err, errgo.Any) } return nil }
func addFile(writer *tar.Writer, filepath string) error { f, err := os.Open(filepath) if err != nil { return err } defer f.Close() fi, err := os.Lstat(filepath) if err != nil { return err } if fi.Mode()&os.ModeSymlink == os.ModeSymlink { target, err := os.Readlink(filepath) if err != nil { return err } return addSymlink(writer, filepath, target) } header, err := tar.FileInfoHeader(fi, "") if err != nil { return err } header.Name = filepath err = writer.WriteHeader(header) if err != nil { return err } n, err := io.Copy(writer, f) if err != nil { return err } if n != fi.Size() { return io.ErrShortWrite } return nil }
func _tar_compress(call otto.FunctionCall) otto.Value { var ( baseDir string ) source, _ := call.Argument(0).ToString() target, _ := call.Argument(1).ToString() filename := filepath.Base(source) target = filepath.Join(target, fmt.Sprintf("%s.tar", filename)) tarfile, err := os.Create(target) if err != nil { jsThrow(call, err) } defer tarfile.Close() tarball := tar.NewWriter(tarfile) defer tarball.Close() info, err := os.Stat(source) if err != nil { jsThrow(call, err) } if info.IsDir() { baseDir = filepath.Base(source) } err = filepath.Walk(source, func(path string, info os.FileInfo, err error) error { if err != nil { return err } header, err := tar.FileInfoHeader(info, info.Name()) if err != nil { return err } if baseDir != "" { header.Name = filepath.Join(baseDir, strings.TrimPrefix(path, source)) } if err := tarball.WriteHeader(header); err != nil { return err } if info.IsDir() { return nil } file, err := os.Open(path) if err != nil { return err } defer file.Close() _, err = io.Copy(tarball, file) return err }) return otto.Value{} }
func recursiveTar(base, file string, tw *tar.Writer) error { filepath := path.Join(base, file) stat, err := os.Stat(filepath) if err != nil { return err } if stat.IsDir() { files, err := ioutil.ReadDir(filepath) if err != nil { return err } for _, f := range files { if err := recursiveTar(base, path.Join(file, f.Name()), tw); err != nil { return err } } return nil } hdr, err := tar.FileInfoHeader(stat, filepath) if err != nil { return err } hdr.Name = file if err := tw.WriteHeader(hdr); err != nil { return err } f, err := os.Open(filepath) if err != nil { return err } defer f.Close() _, err = io.Copy(tw, f) return err }
func targzWalk(dirPath string, tw *tar.Writer) { var walkfunc filepath.WalkFunc walkfunc = func(path string, fi os.FileInfo, err error) error { h, err := tar.FileInfoHeader(fi, "") handleError(err) h.Name = "./app/" + path if fi.Mode()&os.ModeSymlink != 0 { linkPath, err := os.Readlink(path) handleError(err) h.Linkname = linkPath } err = tw.WriteHeader(h) handleError(err) if fi.Mode()&os.ModeDir == 0 && fi.Mode()&os.ModeSymlink == 0 { fr, err := os.Open(path) handleError(err) defer fr.Close() _, err = io.Copy(tw, fr) handleError(err) } return nil } filepath.Walk(dirPath, walkfunc) }
func Tar(base string, w io.Writer) error { tw := tar.NewWriter(w) err := filepath.Walk(base, func(path string, info os.FileInfo, err error) error { name, _ := filepath.Rel(base, path) if name == "." { return nil } hdr, err := tar.FileInfoHeader(info, "") if err != nil { return err } hdr.Name = name tw.WriteHeader(hdr) if info.IsDir() { return nil } // write file content f, err := os.Open(path) if err != nil { return err } _, err = io.Copy(tw, f) f.Close() return err }) if err != nil { return err } return tw.Close() }
func _getFileData(fpath string) (*bytes.Buffer, error) { if data, err := ioutil.ReadFile(fpath); err != nil { return nil, err } else { if fi, err := os.Stat(fpath); err != nil { return nil, err } else { reads := bytes.NewReader(data) var buff bytes.Buffer gw := gzip.NewWriter(&buff) defer gw.Close() tw := tar.NewWriter(gw) defer tw.Close() hdr, err := tar.FileInfoHeader(fi, "") if err != nil { return nil, err } if err := tw.WriteHeader(hdr); err != nil { return nil, err } if _, err := io.Copy(tw, reads); err != nil { return nil, err } return &buff, nil } } }
//addFile adds the file named name as a tar entry named tarname func addFile(name string, tarname string, tw *tar.Writer) error { if tarname == "" { tarname = name } fi, err := os.Stat(name) if err != nil { return err } hdr, err := tar.FileInfoHeader(fi, "") if err != nil { return err } hdr.Name = tarname err = tw.WriteHeader(hdr) if err != nil { return err } f, err := os.Open(name) if err != nil { return err } _, err = io.Copy(tw, f) if err != nil { return err } tw.Flush() return nil }
func (i *dockerInput) addFile(path string, info os.FileInfo, err error) error { if err != nil { return err } th, err := tar.FileInfoHeader(info, path) if err != nil { return err } th.Name = path[1:] //filepath.Join(cpath, path) if si, ok := info.Sys().(*syscall.Stat_t); ok { th.Uid = int(si.Uid) th.Gid = int(si.Gid) } if err := i.tw.WriteHeader(th); err != nil { return err } if !info.Mode().IsDir() { file, err := os.Open(path) if err != nil { return err } if _, err := io.Copy(i.tw, file); err != nil { return err } } return nil }
func walkTarFunc(tw *tar.Writer) filepath.WalkFunc { fn := func(path string, info os.FileInfo, err error) error { if info.Mode().IsDir() { return nil } f, err := os.Open(path) if err != nil { return err } defer f.Close() hdr, err := tar.FileInfoHeader(info, "") hdr.Name = path if err != nil { return err } err = tw.WriteHeader(hdr) if err != nil { return err } _, err = io.Copy(tw, f) if err != nil { return err } return nil } return fn }
func addFileToTar(fileWriter *os.File, tarWriter *tar.Writer, info os.FileInfo, containingPath string, fullPath string) error { var ( relpath string err error ) if relpath, err = filepath.Rel(containingPath, fullPath); err != nil { return err } if relpath == fileWriter.Name() || relpath == "." || relpath == ".." { return nil } if h, _ := tar.FileInfoHeader(info, fullPath); h != nil { h.Name = relpath if err := tarWriter.WriteHeader(h); err != nil { return err } } if !info.IsDir() { fr, err := os.Open(fullPath) if err != nil { return err } defer fr.Close() if _, err := io.Copy(tarWriter, fr); err != nil { return err } } return nil }
// 因为要在 defer 中关闭文件,所以要单独创建一个函数 func tarFile(srcBase, srcRelative string, tw *tar.Writer, fi os.FileInfo) (err error) { // 获取完整路径 srcFull := srcBase + srcRelative // 写入文件信息 hdr, er := tar.FileInfoHeader(fi, "") if er != nil { return er } hdr.Name = srcRelative if er = tw.WriteHeader(hdr); er != nil { return er } // 打开要打包的文件,准备读取 fr, er := os.Open(srcFull) if er != nil { return er } defer fr.Close() // 将文件数据写入 tw 中 if _, er = io.Copy(tw, fr); er != nil { return er } return nil }
// copyFile copies src to tar file dst. func copyFile(tw *tar.Writer, dst, src string) error { s, err := os.Open(src) if err != nil { return fmt.Errorf("unable to open %v: %v", src, err) } defer s.Close() fi, err := s.Stat() if err != nil { return fmt.Errorf("unable to stat %v: %v", src, err) } hdr, err := tar.FileInfoHeader(fi, dst) if err != nil { return fmt.Errorf("unable to create tar header for %v: %v", dst, err) } hdr.Name = dst if err := tw.WriteHeader(hdr); err != nil { return fmt.Errorf("unable to write header for %v: %v", dst, err) } _, err = io.Copy(tw, s) if err != nil { return fmt.Errorf("unable to copy %v to %v: %v", src, dst, err) } return nil }
// AddFile add file from dir in archive tar func (t *TarFile) AddFileWithName(name string, filename string) error { bytearq, err := ioutil.ReadFile(name) if err != nil { return err } info, err := os.Stat(name) if err != nil { return err } header, err := tar.FileInfoHeader(info, "") if err != nil { return err } header.Name = filename err = t.Writer.WriteHeader(header) if err != nil { return err } _, err = t.Writer.Write(bytearq) if err != nil { return err } return nil }
//WriteStreamToPackage writes bytes (from a file reader) to the tarball func WriteStreamToPackage(is io.Reader, localpath string, packagepath string, tw *tar.Writer) error { info, err := os.Stat(localpath) if err != nil { return fmt.Errorf("%s: %s", localpath, err) } header, err := tar.FileInfoHeader(info, localpath) if err != nil { return fmt.Errorf("Error getting FileInfoHeader: %s", err) } //Let's take the variance out of the tar, make headers identical by using zero time oldname := header.Name var zeroTime time.Time header.AccessTime = zeroTime header.ModTime = zeroTime header.ChangeTime = zeroTime header.Name = packagepath if err = tw.WriteHeader(header); err != nil { return fmt.Errorf("Error write header for (path: %s, oldname:%s,newname:%s,sz:%d) : %s", localpath, oldname, packagepath, header.Size, err) } if _, err := io.Copy(tw, is); err != nil { return fmt.Errorf("Error copy (path: %s, oldname:%s,newname:%s,sz:%d) : %s", localpath, oldname, packagepath, header.Size, err) } return nil }
// AddAll adds all files from dir in archive // Tar does not support directories func (t *TarFile) AddAll(dir string, includeCurrentFolder bool) error { dir = path.Clean(dir) return addAll(dir, dir, includeCurrentFolder, func(info os.FileInfo, file io.Reader, entryName string) (err error) { // Skip directory entries if file == nil { return nil } // Create a header based off of the fileinfo header, err := tar.FileInfoHeader(info, "") if err != nil { return err } // Set the header's name to what we want--it may not include the top folder header.Name = entryName // Write the header into the tar file if err := t.Writer.WriteHeader(header); err != nil { return err } // Pipe the file into the tar if _, err := io.Copy(t.Writer, file); err != nil { return err } return nil }) }
func tarDir(srcBase, srcRelative string, tw *tar.Writer, fi os.FileInfo) (err error) { srcFull := srcBase + srcRelative fis, er := ioutil.ReadDir(srcFull) if er != nil { return er } for _, fi := range fis { if fi.IsDir() { tarDir(srcBase, srcRelative+"/"+fi.Name(), tw, fi) } else { tarFile(srcBase, srcRelative+"/"+fi.Name(), tw, fi) } } if len(srcRelative) > 0 { hdr, er := tar.FileInfoHeader(fi, "") if er != nil { return er } hdr.Name = srcRelative if er = tw.WriteHeader(hdr); er != nil { return er } } return nil }
//compress the file (if compress to the zip file , using the similar package: zip.FileInfoHeader) func Filecompress(tw *tar.Writer, dir string, fi os.FileInfo) error { //打开文件 open当中是 目录名称/文件名称 构成的组合 log.Println(dir + fi.Name()) fr, err := os.Open(dir + fi.Name()) log.Println(fr.Name()) if err != nil { return err } defer fr.Close() hdr, err := tar.FileInfoHeader(fi, "") hdr.Name = fr.Name() if err = tw.WriteHeader(hdr); err != nil { return err } _, err = io.Copy(tw, fr) if err != nil { return err } //打印文件名称 log.Println("add the file: " + fi.Name()) return nil }
// writeTarHeader writes tar header for given file, returns error if operation fails func (t *stiTar) writeTarHeader(tarWriter *tar.Writer, dir string, path string, info os.FileInfo, includeDirInPath bool) error { var ( link string err error ) if info.Mode()&os.ModeSymlink != 0 { link, err = os.Readlink(path) if err != nil { return err } } header, err := tar.FileInfoHeader(info, link) if err != nil { return err } prefix := dir if includeDirInPath { prefix = filepath.Dir(prefix) } header.Name = filepath.ToSlash(path[1+len(prefix):]) glog.V(5).Infof("Adding to tar: %s as %s", path, header.Name) if err = tarWriter.WriteHeader(header); err != nil { return err } return nil }
func addFileToTar(fileWriter *os.File, tarWriter *tar.Writer, info os.FileInfo, relativePath, fullPath string) error { if relativePath == fileWriter.Name() || relativePath == "." || relativePath == ".." { return nil } if h, err := tar.FileInfoHeader(info, fullPath); err == nil { h.Name = relativePath if err := tarWriter.WriteHeader(h); err != nil { return err } } if info.IsDir() { return nil } li, err := os.Lstat(fullPath) if err != nil { return err } if li.Mode()&os.ModeSymlink == os.ModeSymlink { return nil } fr, err := os.Open(fullPath) if err != nil { return err } defer fr.Close() if _, err := io.Copy(tarWriter, fr); err != nil { return err } return nil }
func (t *tarmonster) walk(path string, info os.FileInfo, err error) error { if err != nil { return err } if !info.Mode().IsRegular() || info.Size() == 0 { return nil } file, err := os.Open(path) if err != nil { return err } defer file.Close() // Get tar.Header fih, err := tar.FileInfoHeader(info, "") if err != nil { return err } fih.Name = strings.TrimPrefix(path, t.src+string(filepath.Separator)) // Begin a new file if err := t.writer.WriteHeader(fih); err != nil { return err } // Write the file if _, err := io.CopyBuffer(t.writer, file, t.buffer); err != nil { return err } return err }
func (t *Tar) Add(filename string) error { info, rdc, err := statFile(filename) if err != nil { return err } defer rdc.Close() link := "" if info.Mode()&os.ModeSymlink != 0 { link, _ = os.Readlink(filename) } // header hdr, err := tar.FileInfoHeader(info, link) if err != nil { return err } hdr.Name = sanitizedName(filename) if info.IsDir() { hdr.Name += "/" } if err = t.WriteHeader(hdr); err != nil { return fmt.Errorf("header: %v", err) } if info.Mode().IsRegular() { _, err = io.Copy(t, rdc) } return err }