本文整理汇总了Golang中archive/tar.NewWriter函数的典型用法代码示例。如果您正苦于以下问题:Golang NewWriter函数的具体用法?Golang NewWriter怎么用?Golang NewWriter使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了NewWriter函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: NewReader
func NewReader(path path.Path, dag mdag.DAGService, dagnode *mdag.Node, compression int) (*Reader, error) {
reader := &Reader{
signalChan: make(chan struct{}),
dag: dag,
}
var err error
if compression != gzip.NoCompression {
reader.gzipWriter, err = gzip.NewWriterLevel(&reader.buf, compression)
if err != nil {
return nil, err
}
reader.writer = tar.NewWriter(reader.gzipWriter)
} else {
reader.writer = tar.NewWriter(&reader.buf)
}
// writeToBuf will write the data to the buffer, and will signal when there
// is new data to read
_, filename := gopath.Split(path.String())
go reader.writeToBuf(dagnode, filename, 0)
return reader, nil
}
示例2: MakeTarball
func MakeTarball(tarname string, fnames []string) error {
log.Printf("tarring %d entrires to %s ...", len(fnames), tarname)
tarfile, err := os.Create(tarname)
if err != nil {
return err
}
defer tarfile.Close()
var tarwriter *tar.Writer
if strings.HasSuffix(tarname, ".gz") {
zipper := gzip.NewWriter(tarfile)
defer zipper.Close()
tarwriter = tar.NewWriter(zipper)
/*
} else if strings.HasSuffix(tarname, ".xz") {
p := xz.WriterDefaults
p.DictCap = 1 << 24
zipper, err := xz.NewWriterParams(tarfile, &p) //xz.NewWriter(tarfile)
if err != nil {
return err
}
defer zipper.Close()
tarwriter = tar.NewWriter(zipper)
*/
} else {
tarwriter = tar.NewWriter(tarfile)
}
defer tarwriter.Close()
for _, fname := range fnames {
realm, ts, good := util.Parse_FName(fname)
if !good {
log.Printf("warning: skip ill-named file '%s'", fname)
continue // skip
}
data, err := util.Load(fname)
if err != nil {
return err
}
hdr := new(tar.Header)
hdr.Name = util.Make_FName(realm, ts, false)
hdr.Size = int64(len(data))
hdr.ModTime = ts
hdr.Mode = 0644
err = tarwriter.WriteHeader(hdr)
if err != nil {
return err
}
log.Printf("tar %d bytes for file %s", hdr.Size, hdr.Name)
_, err = tarwriter.Write(data)
if err != nil {
return err
}
}
log.Printf("%s tarred without errors", tarname)
return nil
}
示例3: createArchive
func (s *uploadSuite) createArchive(c *gc.C) {
archive, err := os.Create(s.filename)
c.Assert(err, jc.ErrorIsNil)
defer archive.Close()
compressed := gzip.NewWriter(archive)
defer compressed.Close()
tarball := tar.NewWriter(compressed)
defer tarball.Close()
var files = []struct{ Name, Body string }{
{"root.tar", "<state config files>"},
{"dump/oplog.bson", "<something here>"},
}
for _, file := range files {
hdr := &tar.Header{
Name: file.Name,
Size: int64(len(file.Body)),
}
err := tarball.WriteHeader(hdr)
c.Assert(err, jc.ErrorIsNil)
_, err = tarball.Write([]byte(file.Body))
c.Assert(err, jc.ErrorIsNil)
}
}
示例4: TestBuildApiDockerfileSymlink
func (s *DockerSuite) TestBuildApiDockerfileSymlink(c *check.C) {
// Test to make sure we stop people from trying to leave the
// build context when specifying a symlink as the path to the dockerfile
buffer := new(bytes.Buffer)
tw := tar.NewWriter(buffer)
defer tw.Close()
if err := tw.WriteHeader(&tar.Header{
Name: "Dockerfile",
Typeflag: tar.TypeSymlink,
Linkname: "/etc/passwd",
}); err != nil {
c.Fatalf("failed to write tar file header: %v", err)
}
if err := tw.Close(); err != nil {
c.Fatalf("failed to close tar archive: %v", err)
}
res, body, err := sockRequestRaw("POST", "/build", buffer, "application/x-tar")
c.Assert(res.StatusCode, check.Equals, http.StatusInternalServerError)
c.Assert(err, check.IsNil)
out, err := readBody(body)
if err != nil {
c.Fatal(err)
}
// The reason the error is "Cannot locate specified Dockerfile" is because
// in the builder, the symlink is resolved within the context, therefore
// Dockerfile -> /etc/passwd becomes etc/passwd from the context which is
// a nonexistent file.
if !strings.Contains(string(out), "Cannot locate specified Dockerfile: Dockerfile") {
c.Fatalf("Didn't complain about leaving build context: %s", out)
}
}
示例5: Archive
// Archive writes the executable files found in the given directory in
// gzipped tar format to w.
func Archive(w io.Writer, dir string) error {
entries, err := ioutil.ReadDir(dir)
if err != nil {
return err
}
gzw := gzip.NewWriter(w)
defer closeErrorCheck(&err, gzw)
tarw := tar.NewWriter(gzw)
defer closeErrorCheck(&err, tarw)
for _, ent := range entries {
h := tarHeader(ent)
logger.Debugf("adding entry: %#v", h)
// ignore local umask
if isExecutable(ent) {
h.Mode = 0755
} else {
h.Mode = 0644
}
err := tarw.WriteHeader(h)
if err != nil {
return err
}
fileName := filepath.Join(dir, ent.Name())
if err := copyFile(tarw, fileName); err != nil {
return err
}
}
return nil
}
示例6: Run
func (c *PackCmd) Run() error {
pkgdir := os.ExpandEnv("$GOPATH/pkg")
c.log.Logv("Package dir: %s", pkgdir)
files, err := ioutil.ReadDir(pkgdir)
if err != nil {
return err
}
writer := tar.NewWriter(c.writer)
defer func() {
if err := writer.Close(); err != nil {
panic(err)
}
}()
for _, f := range files {
if f.IsDir() {
c.log.Logv("OS/Arch: %s", f.Name())
if err := c.packLib(writer, f.Name()); err == nil {
if err = c.packSource(writer, c.Paths); err != nil {
panic(err)
}
} else if os.IsNotExist(err) {
c.log.Logv("not built")
continue // it might not be built for this combo
} else {
panic(err)
}
}
}
return nil
}
示例7: writer
func (a *Archive) writer() (*tharWriter, error) {
writer := io.Writer(a.Stream)
flushers := []flushableWriter{}
closers := []closeableWriter{}
if a.Options.GZip {
if a.Options.GZipLevel > 0 {
gw, err := gzip.NewWriterLevel(writer, a.Options.GZipLevel)
if err != nil {
return nil, err
}
flushers = append([]flushableWriter{gw}, flushers...)
closers = append([]closeableWriter{gw}, closers...)
writer = gw
} else {
writer = gzip.NewWriter(writer)
}
}
tw := tar.NewWriter(writer)
flushers = append([]flushableWriter{tw}, flushers...)
return &tharWriter{
Writer: tw,
Flushers: flushers,
Closers: closers,
}, nil
}
示例8: Backup
// Backup will write a tar archive of any TSM files modified since the passed
// in time to the passed in writer. The basePath will be prepended to the names
// of the files in the archive. It will force a snapshot of the WAL first
// then perform the backup with a read lock against the file store. This means
// that new TSM files will not be able to be created in this shard while the
// backup is running. For shards that are still acively getting writes, this
// could cause the WAL to backup, increasing memory usage and evenutally rejecting writes.
func (e *Engine) Backup(w io.Writer, basePath string, since time.Time) error {
if err := e.WriteSnapshot(); err != nil {
return err
}
e.FileStore.mu.RLock()
defer e.FileStore.mu.RUnlock()
var files []FileStat
// grab all the files and tombstones that have a modified time after since
for _, f := range e.FileStore.files {
if stat := f.Stats(); stat.LastModified > since.UnixNano() {
files = append(files, f.Stats())
}
for _, t := range f.TombstoneFiles() {
if t.LastModified > since.UnixNano() {
files = append(files, f.Stats())
}
}
}
tw := tar.NewWriter(w)
defer tw.Close()
for _, f := range files {
if err := e.writeFileToBackup(f, basePath, tw); err != nil {
return err
}
}
return nil
}
示例9: newDebugInfo
// newDebugInfo initializes the global debug handler.
func newDebugInfo(name string, w io.Writer) (*debugInfo, error) {
gz := gzip.NewWriter(w)
d := &debugInfo{
name: name,
w: w,
gz: gz,
tar: tar.NewWriter(gz),
}
// create the subdirs we need
topHdr := &tar.Header{
Name: name,
Typeflag: tar.TypeDir,
Mode: 0755,
}
graphsHdr := &tar.Header{
Name: name + "/graphs",
Typeflag: tar.TypeDir,
Mode: 0755,
}
err := d.tar.WriteHeader(topHdr)
// if the first errors, the second will too
err = d.tar.WriteHeader(graphsHdr)
if err != nil {
return nil, err
}
return d, nil
}
示例10: newExportAction
func newExportAction(c *cli.Context) {
if len(c.Args()) > 1 {
fmt.Fprintln(os.Stderr, "At most one host name could be provided.")
os.Exit(1)
}
if _, err := depot.GetCertificateAuthority(d); isFileNotExist(err) {
fmt.Fprintln(os.Stderr, "Please run 'ca-ctl init' to initial the depot.")
os.Exit(1)
}
var files []*TarFile
var err error
if len(c.Args()) == 0 {
files, err = getAuthFiles(c)
} else {
files, err = getHostFiles(c, c.Args()[0])
}
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
w := tar.NewWriter(os.Stdout)
defer w.Close()
if err = outputTarFiles(w, files); err != nil {
fmt.Fprintln(os.Stderr, "Save tar error:", err)
os.Exit(1)
}
}
示例11: newTestTar
func newTestTar(entries []*testTarEntry, dir string) (string, error) {
t, err := ioutil.TempFile(dir, "tar")
if err != nil {
return "", err
}
defer t.Close()
tw := tar.NewWriter(t)
for _, entry := range entries {
// Add default mode
if entry.header.Mode == 0 {
if entry.header.Typeflag == tar.TypeDir {
entry.header.Mode = 0755
} else {
entry.header.Mode = 0644
}
}
// Add calling user uid and gid or tests will fail
entry.header.Uid = os.Getuid()
entry.header.Gid = os.Getgid()
if err := tw.WriteHeader(entry.header); err != nil {
return "", err
}
if _, err := io.WriteString(tw, entry.contents); err != nil {
return "", err
}
}
if err := tw.Close(); err != nil {
return "", err
}
return t.Name(), nil
}
示例12: createImageInput
// createImageInput creates a tar reader using the given templates as files.
// The given vars are replaced in all the templates encountered.
func createImageInput(tmpls, vars map[string]string) (io.Reader, error) {
var buf bytes.Buffer
tarW := stdtar.NewWriter(&buf)
header := &stdtar.Header{
Mode: 0644,
}
for path, tmpl := range tmpls {
if vars != nil {
for key, val := range vars {
tmpl = strings.Replace(tmpl, "{{"+key+"}}", val, -1)
}
}
header.Name = path
header.Size = int64(len(tmpl))
err := tarW.WriteHeader(header)
if err != nil {
return nil, err
}
_, err = io.Copy(tarW, strings.NewReader(tmpl))
if err != nil {
return nil, err
}
}
return &buf, tarW.Close()
}
示例13: _tar_compress
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{}
}
示例14: TarGZ
func TarGZ(files []ExportFile) ([]byte, error) {
tarBuffer := new(bytes.Buffer)
tarWriter := tar.NewWriter(tarBuffer)
for _, file := range files {
header := &tar.Header{
Name: file.Name,
Mode: int64(file.Mode),
Size: int64(len(file.Content)),
ModTime: time.Now(),
}
if err := tarWriter.WriteHeader(header); err != nil {
return nil, err
}
if _, err := tarWriter.Write(file.Content); err != nil {
return nil, err
}
}
if err := tarWriter.Close(); err != nil {
return nil, err
}
zipBuffer := new(bytes.Buffer)
zipWriter := gzip.NewWriter(zipBuffer)
zipWriter.Write(tarBuffer.Bytes())
zipWriter.Close()
return zipBuffer.Bytes(), nil
}
示例15: targz
func targz(ctx *cmd.Context, destination io.Writer, filepaths ...string) error {
var buf bytes.Buffer
tarWriter := tar.NewWriter(&buf)
for _, path := range filepaths {
if path == ".." {
fmt.Fprintf(ctx.Stderr, "Warning: skipping %q", path)
continue
}
fi, err := os.Lstat(path)
if err != nil {
return err
}
if fi.IsDir() {
if len(filepaths) == 1 && path != "." {
return singleDir(ctx, destination, path)
}
err = addDir(tarWriter, path)
} else {
err = addFile(tarWriter, path)
}
if err != nil {
return err
}
}
err := tarWriter.Close()
if err != nil {
return err
}
gzipWriter := gzip.NewWriter(destination)
defer gzipWriter.Close()
_, err = io.Copy(gzipWriter, &buf)
return err
}