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
}
// 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
}
// zipInputFiles deterministically builds a zip archive out of input files and
// writes it to the writer. Files are written in the order given.
func zipInputFiles(files []File, w io.Writer, log logging.Logger) error {
writer := zip.NewWriter(w)
defer writer.Close()
// Reports zipping progress to the log each second.
lastReport := time.Time{}
progress := func(count int) {
if time.Since(lastReport) > time.Second {
lastReport = time.Now()
log.Infof("Zipping files: %d files left", len(files)-count)
}
}
for i, in := range files {
progress(i)
// Intentionally do not add timestamp or file mode to make zip archive
// deterministic. See also zip.FileInfoHeader() implementation.
fh := zip.FileHeader{
Name: in.Name(),
Method: zip.Deflate,
}
mode := os.FileMode(0600)
if in.Executable() {
mode |= 0100
}
if in.Symlink() {
mode |= os.ModeSymlink
}
fh.SetMode(mode)
dst, err := writer.CreateHeader(&fh)
if err != nil {
return err
}
if in.Symlink() {
err = zipSymlinkFile(dst, in)
} else {
err = zipRegularFile(dst, in)
}
if err != nil {
return err
}
}
return nil
}
// Zipper zips file contents at a path. Helper to prepare zipped data for upload
// to S3.
func Zipper(zipPath string) (*bytes.Buffer, error) {
f, err := os.Open(zipPath)
if err != nil {
return nil, err
}
defer f.Close()
buffer := bytes.NewBuffer(nil)
w := zip.NewWriter(buffer)
fh := zip.FileHeader{}
fh.Name = filepath.Base(zipPath)
fh.SetMode(0755)
// Add some files to the archive.
var files = []struct {
Name string
FileHandle *os.File
Header *zip.FileHeader
}{
{fh.Name, f, &fh},
}
// Loop through all files listed above
// Can be created using file.Name or a custom file.Header for flexibility.
// To set permissions you need to use the file.Header construct.
for _, file := range files {
var zf io.Writer
if file.Header == nil {
zf, err = w.Create(file.Name)
} else {
zf, err = w.CreateHeader(file.Header)
}
if err != nil {
return nil, err
}
if _, err := io.Copy(zf, f); err != nil {
return nil, err
}
}
if err := w.Close(); err != nil {
return nil, err
}
return buffer, nil
}
func (zwp *ZipWriterPool) GetWriter(fileIndex int64) (io.WriteCloser, error) {
file := zwp.container.Files[fileIndex]
fh := zip.FileHeader{
Name: file.Path,
UncompressedSize64: uint64(file.Size),
Method: zip.Deflate,
}
fh.SetMode(os.FileMode(file.Mode))
fh.SetModTime(time.Now())
w, err := zwp.zw.CreateHeader(&fh)
if err != nil {
return nil, errors.Wrap(err, 1)
}
return &nopWriteCloser{w}, nil
}
Expect(err).NotTo(HaveOccurred())
Expect(os.Chdir(tmpDir)).To(Succeed())
tmpFile, err = ioutil.TempFile("", "zipfile")
Expect(err).NotTo(HaveOccurred())
defer tmpFile.Close()
zipWriter := zip.NewWriter(tmpFile)
defer zipWriter.Close()
var (
header *zip.FileHeader
)
header = &zip.FileHeader{Name: "aaa"}
header.SetMode(os.FileMode(0644))
_, err = zipWriter.CreateHeader(header)
Expect(err).NotTo(HaveOccurred())
header = &zip.FileHeader{Name: "bbb/1.txt"}
header.SetMode(os.FileMode(0640))
_, err = zipWriter.CreateHeader(header)
Expect(err).NotTo(HaveOccurred())
header = &zip.FileHeader{Name: "bbb/2.txt"}
header.SetMode(os.FileMode(0600))
_, err = zipWriter.CreateHeader(header)
Expect(err).NotTo(HaveOccurred())
header = &zip.FileHeader{Name: "ddd/3.txt"}
header.SetMode(os.FileMode(0600))
func CompressZip(archiveWriter io.Writer, container *tlc.Container, pool wsync.Pool, consumer *state.Consumer) (*archiver.CompressResult, error) {
var err error
var uncompressedSize int64
var compressedSize int64
archiveCounter := counter.NewWriter(archiveWriter)
zipWriter := zip.NewWriter(archiveCounter)
defer zipWriter.Close()
defer func() {
if zipWriter != nil {
if zErr := zipWriter.Close(); err == nil && zErr != nil {
err = errors.Wrap(zErr, 1)
}
}
}()
for _, dir := range container.Dirs {
fh := zip.FileHeader{
Name: dir.Path + "/",
}
fh.SetMode(os.FileMode(dir.Mode))
fh.SetModTime(time.Now())
_, hErr := zipWriter.CreateHeader(&fh)
if hErr != nil {
return nil, errors.Wrap(hErr, 1)
}
}
for fileIndex, file := range container.Files {
fh := zip.FileHeader{
Name: file.Path,
UncompressedSize64: uint64(file.Size),
Method: zip.Deflate,
}
fh.SetMode(os.FileMode(file.Mode))
fh.SetModTime(time.Now())
entryWriter, eErr := zipWriter.CreateHeader(&fh)
if eErr != nil {
return nil, errors.Wrap(eErr, 1)
}
entryReader, eErr := pool.GetReader(int64(fileIndex))
if eErr != nil {
return nil, errors.Wrap(eErr, 1)
}
copiedBytes, eErr := io.Copy(entryWriter, entryReader)
if eErr != nil {
return nil, errors.Wrap(eErr, 1)
}
uncompressedSize += copiedBytes
}
for _, symlink := range container.Symlinks {
fh := zip.FileHeader{
Name: symlink.Path,
}
fh.SetMode(os.FileMode(symlink.Mode))
entryWriter, eErr := zipWriter.CreateHeader(&fh)
if eErr != nil {
return nil, errors.Wrap(eErr, 1)
}
entryWriter.Write([]byte(symlink.Dest))
}
err = zipWriter.Close()
if err != nil {
return nil, errors.Wrap(err, 1)
}
zipWriter = nil
compressedSize = archiveCounter.Count()
return &archiver.CompressResult{
UncompressedSize: uncompressedSize,
CompressedSize: compressedSize,
}, nil
}
