From 231b98dd68104ced9ec0bdb23b7c643e8c52292d Mon Sep 17 00:00:00 2001 From: Kyle Isom Date: Sat, 15 Sep 2018 15:08:37 -0700 Subject: [PATCH] Add kgz, a gzip tool. --- README.md | 2 + cmd/kgz/README | 23 ++++++ cmd/kgz/main.go | 182 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 207 insertions(+) create mode 100644 cmd/kgz/README create mode 100644 cmd/kgz/main.go diff --git a/README.md b/README.md index 0d05ce9..7388c72 100644 --- a/README.md +++ b/README.md @@ -25,6 +25,8 @@ Contents: csrpubdump/ Dump the public key from an X.509 certificate request. fragment/ Print a fragment of a file. jlp/ JSON linter/prettifier. + kgz/ Custom gzip compressor / decompressor that handles 99% + of my use cases. pem2bin/ Dump the binary body of a PEM-encoded block. pembody/ Print the body of a PEM certificate. pemit/ Dump data to a PEM file. diff --git a/cmd/kgz/README b/cmd/kgz/README new file mode 100644 index 0000000..382ef36 --- /dev/null +++ b/cmd/kgz/README @@ -0,0 +1,23 @@ +kgz + +kgz is like gzip, but supports compressing and decompressing to a different +directory than the source file is in. + +Usage: kgz [-l] source [target] + +If target is a directory, the basename of the sourcefile will be used +as the target filename. Compression and decompression is selected +based on whether the source filename ends in ".gz". + +Flags: + -l level Compression level (0-9). Only meaninful when + compressing a file. + + + + + + + + + diff --git a/cmd/kgz/main.go b/cmd/kgz/main.go new file mode 100644 index 0000000..26949ee --- /dev/null +++ b/cmd/kgz/main.go @@ -0,0 +1,182 @@ +package main + +import ( + "compress/flate" + "compress/gzip" + "flag" + "fmt" + "io" + "os" + "path/filepath" + "strings" + + "github.com/pkg/errors" +) + +const gzipExt = ".gz" + +func compress(path, target string, level int) error { + sourceFile, err := os.Open(path) + if err != nil { + return errors.Wrap(err, "opening file for read") + } + defer sourceFile.Close() + + destFile, err := os.Create(target) + if err != nil { + return errors.Wrap(err, "opening file for write") + } + defer destFile.Close() + + gzipCompressor, err := gzip.NewWriterLevel(destFile, level) + if err != nil { + return errors.Wrap(err, "invalid compression level") + } + defer gzipCompressor.Close() + + _, err = io.Copy(gzipCompressor, sourceFile) + if err != nil { + return errors.Wrap(err, "compressing file") + } + + if err != nil { + return errors.Wrap(err, "stat(2)ing destination file") + } + + return nil +} + +func uncompress(path, target string) error { + sourceFile, err := os.Open(path) + if err != nil { + return errors.Wrap(err, "opening file for read") + } + defer sourceFile.Close() + + gzipUncompressor, err := gzip.NewReader(sourceFile) + if err != nil { + return errors.Wrap(err, "reading gzip headers") + } + defer gzipUncompressor.Close() + + destFile, err := os.Create(target) + if err != nil { + return errors.Wrap(err, "opening file for write") + } + defer destFile.Close() + + _, err = io.Copy(destFile, gzipUncompressor) + if err != nil { + return errors.Wrap(err, "uncompressing file") + } + + return nil +} + +func usage(w io.Writer) { + fmt.Fprintf(w, `Usage: %s [-l] source [target] + +kgz is like gzip, but supports compressing and decompressing to a different +directory than the source file is in. + +Flags: + -l level Compression level (0-9). Only meaninful when + compressing a file. +`, os.Args[0]) +} + +func init() { + flag.Usage = func() { usage(os.Stderr) } +} + +func isDir(path string) bool { + file, err := os.Open(path) + if err == nil { + defer file.Close() + stat, err := file.Stat() + if err != nil { + return false + } + + if stat.IsDir() { + return true + } + } + + return false +} + +func pathForUncompressing(source, dest string) (string, error) { + if !isDir(dest) { + return dest, nil + } + + source = filepath.Base(source) + if !strings.HasSuffix(source, gzipExt) { + return "", errors.Errorf("%s is a not gzip-compressed file") + } + outFile := source[:len(source)-len(gzipExt)] + outFile = filepath.Join(dest, outFile) + return outFile, nil +} + +func pathForCompressing(source, dest string) (string, error) { + if !isDir(dest) { + return dest, nil + } + + source = filepath.Base(source) + if strings.HasSuffix(source, gzipExt) { + return "", errors.Errorf("%s is a gzip-compressed file") + } + + dest = filepath.Join(dest, source+gzipExt) + return dest, nil +} + +func main() { + var level int + var path string + var target = "." + + flag.IntVar(&level, "l", flate.DefaultCompression, "compression level") + flag.Parse() + + if flag.NArg() < 1 || flag.NArg() > 2 { + usage(os.Stderr) + os.Exit(1) + } + + path = flag.Arg(0) + if flag.NArg() == 2 { + target = flag.Arg(1) + } + + if strings.HasSuffix(path, gzipExt) { + target, err := pathForUncompressing(path, target) + if err != nil { + fmt.Fprintf(os.Stderr, "%s\n", err) + os.Exit(1) + } + + err = uncompress(path, target) + if err != nil { + os.Remove(target) + fmt.Fprintf(os.Stderr, "%s\n", err) + os.Exit(1) + } + } else { + target, err := pathForCompressing(path, target) + if err != nil { + fmt.Fprintf(os.Stderr, "%s\n", err) + os.Exit(1) + } + + err = compress(path, target, level) + if err != nil { + os.Remove(target) + fmt.Fprintf(os.Stderr, "%s\n", err) + os.Exit(1) + } + } +}