mirror of https://github.com/beego/bee.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
577 lines
12 KiB
577 lines
12 KiB
package pack |
|
|
|
import ( |
|
"archive/tar" |
|
"archive/zip" |
|
"compress/gzip" |
|
"flag" |
|
"fmt" |
|
"io" |
|
"os" |
|
"os/exec" |
|
path "path/filepath" |
|
"regexp" |
|
"runtime" |
|
"sort" |
|
"strconv" |
|
"strings" |
|
"syscall" |
|
"time" |
|
|
|
"github.com/beego/bee/cmd/commands" |
|
"github.com/beego/bee/cmd/commands/version" |
|
beeLogger "github.com/beego/bee/logger" |
|
"github.com/beego/bee/utils" |
|
) |
|
|
|
var CmdPack = &commands.Command{ |
|
CustomFlags: true, |
|
UsageLine: "pack", |
|
Short: "Compresses a Beego application into a single file", |
|
Long: `Pack is used to compress Beego applications into a tarball/zip file. |
|
This eases the deployment by directly extracting the file to a server. |
|
|
|
{{"Example:"|bold}} |
|
$ bee pack -v -ba="-ldflags '-s -w'" |
|
`, |
|
PreRun: func(cmd *commands.Command, args []string) { version.ShowShortVersionBanner() }, |
|
Run: packApp, |
|
} |
|
|
|
var ( |
|
appPath string |
|
excludeP string |
|
excludeS string |
|
outputP string |
|
excludeR utils.ListOpts |
|
fsym bool |
|
ssym bool |
|
build bool |
|
buildArgs string |
|
buildEnvs utils.ListOpts |
|
verbose bool |
|
format string |
|
) |
|
|
|
func init() { |
|
fs := flag.NewFlagSet("pack", flag.ContinueOnError) |
|
fs.StringVar(&appPath, "p", "", "Set the application path. Defaults to the current path.") |
|
fs.BoolVar(&build, "b", true, "Tell the command to do a build for the current platform. Defaults to true.") |
|
fs.StringVar(&buildArgs, "ba", "", "Specify additional args for Go build.") |
|
fs.Var(&buildEnvs, "be", "Specify additional env variables for Go build. e.g. GOARCH=arm.") |
|
fs.StringVar(&outputP, "o", "", "Set the compressed file output path. Defaults to the current path.") |
|
fs.StringVar(&format, "f", "tar.gz", "Set file format. Either tar.gz or zip. Defaults to tar.gz.") |
|
fs.StringVar(&excludeP, "exp", ".", "Set prefixes of paths to be excluded. Uses a column (:) as separator.") |
|
fs.StringVar(&excludeS, "exs", ".go:.DS_Store:.tmp", "Set suffixes of paths to be excluded. Uses a column (:) as separator.") |
|
fs.Var(&excludeR, "exr", "Set a regular expression of files to be excluded.") |
|
fs.BoolVar(&fsym, "fs", false, "Tell the command to follow symlinks. Defaults to false.") |
|
fs.BoolVar(&ssym, "ss", false, "Tell the command to skip symlinks. Defaults to false.") |
|
fs.BoolVar(&verbose, "v", false, "Be more verbose during the operation. Defaults to false.") |
|
CmdPack.Flag = *fs |
|
commands.AvailableCommands = append(commands.AvailableCommands, CmdPack) |
|
} |
|
|
|
type walker interface { |
|
isExclude(string) bool |
|
isEmpty(string) bool |
|
relName(string) string |
|
virPath(string) string |
|
compress(string, string, os.FileInfo) (bool, error) |
|
walkRoot(string) error |
|
} |
|
|
|
type byName []os.FileInfo |
|
|
|
func (f byName) Len() int { return len(f) } |
|
func (f byName) Less(i, j int) bool { return f[i].Name() < f[j].Name() } |
|
func (f byName) Swap(i, j int) { f[i], f[j] = f[j], f[i] } |
|
|
|
type walkFileTree struct { |
|
wak walker |
|
prefix string |
|
excludePrefix []string |
|
excludeRegexp []*regexp.Regexp |
|
excludeSuffix []string |
|
allfiles map[string]bool |
|
output *io.Writer |
|
} |
|
|
|
func (wft *walkFileTree) isExclude(fPath string) bool { |
|
if fPath == "" { |
|
return true |
|
} |
|
|
|
for _, prefix := range wft.excludePrefix { |
|
if strings.HasPrefix(fPath, prefix) { |
|
return true |
|
} |
|
} |
|
for _, suffix := range wft.excludeSuffix { |
|
if strings.HasSuffix(fPath, suffix) { |
|
return true |
|
} |
|
} |
|
return false |
|
} |
|
|
|
func (wft *walkFileTree) isExcludeName(name string) bool { |
|
for _, r := range wft.excludeRegexp { |
|
if r.MatchString(name) { |
|
return true |
|
} |
|
} |
|
|
|
return false |
|
} |
|
|
|
func (wft *walkFileTree) isEmpty(fpath string) bool { |
|
fh, _ := os.Open(fpath) |
|
defer fh.Close() |
|
infos, _ := fh.Readdir(-1) |
|
for _, fi := range infos { |
|
fn := fi.Name() |
|
fp := path.Join(fpath, fn) |
|
if wft.isExclude(wft.virPath(fp)) { |
|
continue |
|
} |
|
if wft.isExcludeName(fn) { |
|
continue |
|
} |
|
if fi.Mode()&os.ModeSymlink > 0 { |
|
continue |
|
} |
|
if fi.IsDir() && wft.isEmpty(fp) { |
|
continue |
|
} |
|
return false |
|
} |
|
return true |
|
} |
|
|
|
func (wft *walkFileTree) relName(fpath string) string { |
|
name, _ := path.Rel(wft.prefix, fpath) |
|
return name |
|
} |
|
|
|
func (wft *walkFileTree) virPath(fpath string) string { |
|
name := fpath[len(wft.prefix):] |
|
if name == "" { |
|
return "" |
|
} |
|
name = name[1:] |
|
name = path.ToSlash(name) |
|
return name |
|
} |
|
|
|
func (wft *walkFileTree) readDir(dirname string) ([]os.FileInfo, error) { |
|
f, err := os.Open(dirname) |
|
if err != nil { |
|
return nil, err |
|
} |
|
list, err := f.Readdir(-1) |
|
f.Close() |
|
if err != nil { |
|
return nil, err |
|
} |
|
sort.Sort(byName(list)) |
|
return list, nil |
|
} |
|
|
|
func (wft *walkFileTree) walkLeaf(fpath string, fi os.FileInfo, err error) error { |
|
if err != nil { |
|
return err |
|
} |
|
|
|
if fpath == outputP { |
|
return nil |
|
} |
|
|
|
if fi.IsDir() { |
|
return nil |
|
} |
|
|
|
if ssym && fi.Mode()&os.ModeSymlink > 0 { |
|
return nil |
|
} |
|
|
|
name := wft.virPath(fpath) |
|
|
|
if wft.allfiles[name] { |
|
return nil |
|
} |
|
|
|
if added, err := wft.wak.compress(name, fpath, fi); added { |
|
if verbose { |
|
fmt.Fprintf(*wft.output, "\t%s%scompressed%s\t %s%s\n", "\x1b[32m", "\x1b[1m", "\x1b[21m", name, "\x1b[0m") |
|
} |
|
wft.allfiles[name] = true |
|
return err |
|
} |
|
return err |
|
} |
|
|
|
func (wft *walkFileTree) iterDirectory(fpath string, fi os.FileInfo) error { |
|
doFSym := fsym && fi.Mode()&os.ModeSymlink > 0 |
|
if doFSym { |
|
nfi, err := os.Stat(fpath) |
|
if os.IsNotExist(err) { |
|
return nil |
|
} |
|
fi = nfi |
|
} |
|
|
|
relPath := wft.virPath(fpath) |
|
|
|
if len(relPath) > 0 { |
|
if wft.isExcludeName(fi.Name()) { |
|
return nil |
|
} |
|
|
|
if wft.isExclude(relPath) { |
|
return nil |
|
} |
|
} |
|
|
|
err := wft.walkLeaf(fpath, fi, nil) |
|
if err != nil { |
|
if fi.IsDir() && err == path.SkipDir { |
|
return nil |
|
} |
|
return err |
|
} |
|
|
|
if !fi.IsDir() { |
|
return nil |
|
} |
|
|
|
list, err := wft.readDir(fpath) |
|
if err != nil { |
|
return wft.walkLeaf(fpath, fi, err) |
|
} |
|
|
|
for _, fileInfo := range list { |
|
err = wft.iterDirectory(path.Join(fpath, fileInfo.Name()), fileInfo) |
|
if err != nil { |
|
if !fileInfo.IsDir() || err != path.SkipDir { |
|
return err |
|
} |
|
} |
|
} |
|
return nil |
|
} |
|
|
|
func (wft *walkFileTree) walkRoot(root string) error { |
|
wft.prefix = root |
|
fi, err := os.Stat(root) |
|
if err != nil { |
|
return err |
|
} |
|
return wft.iterDirectory(root, fi) |
|
} |
|
|
|
type tarWalk struct { |
|
walkFileTree |
|
tw *tar.Writer |
|
} |
|
|
|
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 { |
|
fr, err := os.Open(fpath) |
|
if err != nil { |
|
return false, err |
|
} |
|
defer utils.CloseFile(fr) |
|
_, err = io.Copy(tw, fr) |
|
if err != nil { |
|
return false, err |
|
} |
|
tw.Flush() |
|
} |
|
|
|
return true, nil |
|
} |
|
|
|
type zipWalk struct { |
|
walkFileTree |
|
zw *zip.Writer |
|
} |
|
|
|
func (wft *zipWalk) compress(name, fpath string, fi os.FileInfo) (bool, error) { |
|
isSym := fi.Mode()&os.ModeSymlink > 0 |
|
|
|
hdr, err := zip.FileInfoHeader(fi) |
|
if err != nil { |
|
return false, err |
|
} |
|
hdr.Name = name |
|
|
|
zw := wft.zw |
|
w, err := zw.CreateHeader(hdr) |
|
if err != nil { |
|
return false, err |
|
} |
|
|
|
if !isSym { |
|
fr, err := os.Open(fpath) |
|
if err != nil { |
|
return false, err |
|
} |
|
defer utils.CloseFile(fr) |
|
_, err = io.Copy(w, fr) |
|
if err != nil { |
|
return false, err |
|
} |
|
} else { |
|
var link string |
|
if link, err = os.Readlink(fpath); err != nil { |
|
return false, err |
|
} |
|
_, err = w.Write([]byte(link)) |
|
if err != nil { |
|
return false, err |
|
} |
|
} |
|
|
|
return true, nil |
|
} |
|
|
|
func packDirectory(output io.Writer, excludePrefix []string, excludeSuffix []string, |
|
excludeRegexp []*regexp.Regexp, includePath ...string) (err error) { |
|
|
|
beeLogger.Log.Infof("Excluding relpath prefix: %s", strings.Join(excludePrefix, ":")) |
|
beeLogger.Log.Infof("Excluding relpath suffix: %s", strings.Join(excludeSuffix, ":")) |
|
if len(excludeRegexp) > 0 { |
|
beeLogger.Log.Infof("Excluding filename regex: `%s`", strings.Join(excludeR, "`, `")) |
|
} |
|
|
|
w, err := os.OpenFile(outputP, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644) |
|
if err != nil { |
|
return err |
|
} |
|
|
|
var wft walker |
|
|
|
if format == "zip" { |
|
walk := new(zipWalk) |
|
walk.output = &output |
|
zw := zip.NewWriter(w) |
|
defer func() { |
|
zw.Close() |
|
}() |
|
walk.allfiles = make(map[string]bool) |
|
walk.zw = zw |
|
walk.wak = walk |
|
walk.excludePrefix = excludePrefix |
|
walk.excludeSuffix = excludeSuffix |
|
walk.excludeRegexp = excludeRegexp |
|
wft = walk |
|
} else { |
|
walk := new(tarWalk) |
|
walk.output = &output |
|
cw := gzip.NewWriter(w) |
|
tw := tar.NewWriter(cw) |
|
|
|
defer func() { |
|
tw.Flush() |
|
cw.Flush() |
|
tw.Close() |
|
cw.Close() |
|
}() |
|
walk.allfiles = make(map[string]bool) |
|
walk.tw = tw |
|
walk.wak = walk |
|
walk.excludePrefix = excludePrefix |
|
walk.excludeSuffix = excludeSuffix |
|
walk.excludeRegexp = excludeRegexp |
|
wft = walk |
|
} |
|
|
|
for _, p := range includePath { |
|
err = wft.walkRoot(p) |
|
if err != nil { |
|
return |
|
} |
|
} |
|
|
|
return |
|
} |
|
|
|
func packApp(cmd *commands.Command, args []string) int { |
|
output := cmd.Out() |
|
curPath, _ := os.Getwd() |
|
var thePath string |
|
|
|
nArgs := []string{} |
|
has := false |
|
for _, a := range args { |
|
if a != "" && a[0] == '-' { |
|
has = true |
|
} |
|
if has { |
|
nArgs = append(nArgs, a) |
|
} |
|
} |
|
cmd.Flag.Parse(nArgs) |
|
|
|
if !path.IsAbs(appPath) { |
|
appPath = path.Join(curPath, appPath) |
|
} |
|
|
|
thePath, err := path.Abs(appPath) |
|
if err != nil { |
|
beeLogger.Log.Fatalf("Wrong application path: %s", thePath) |
|
} |
|
if stat, err := os.Stat(thePath); os.IsNotExist(err) || !stat.IsDir() { |
|
beeLogger.Log.Fatalf("Application path does not exist: %s", thePath) |
|
} |
|
|
|
beeLogger.Log.Infof("Packaging application on '%s'...", thePath) |
|
|
|
appName := path.Base(thePath) |
|
|
|
goos := runtime.GOOS |
|
if v, found := syscall.Getenv("GOOS"); found { |
|
goos = v |
|
} |
|
goarch := runtime.GOARCH |
|
if v, found := syscall.Getenv("GOARCH"); found { |
|
goarch = v |
|
} |
|
|
|
str := strconv.FormatInt(time.Now().UnixNano(), 10)[9:] |
|
|
|
tmpdir := path.Join(os.TempDir(), "beePack-"+str) |
|
|
|
os.Mkdir(tmpdir, 0700) |
|
defer func() { |
|
// Remove the tmpdir once bee pack is done |
|
err := os.RemoveAll(tmpdir) |
|
if err != nil { |
|
beeLogger.Log.Error("Failed to remove the generated temp dir") |
|
} |
|
}() |
|
|
|
if build { |
|
beeLogger.Log.Info("Building application...") |
|
var envs []string |
|
for _, env := range buildEnvs { |
|
parts := strings.SplitN(env, "=", 2) |
|
if len(parts) == 2 { |
|
k, v := strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1]) |
|
if len(k) > 0 && len(v) > 0 { |
|
switch k { |
|
case "GOOS": |
|
goos = v |
|
case "GOARCH": |
|
goarch = v |
|
default: |
|
envs = append(envs, fmt.Sprintf("%s=%s", k, v)) |
|
} |
|
} |
|
} |
|
} |
|
|
|
os.Setenv("GOOS", goos) |
|
os.Setenv("GOARCH", goarch) |
|
|
|
beeLogger.Log.Infof("Using: GOOS=%s GOARCH=%s", goos, goarch) |
|
|
|
binPath := path.Join(tmpdir, appName) |
|
if goos == "windows" { |
|
binPath += ".exe" |
|
} |
|
|
|
args := []string{"build", "-o", binPath} |
|
if len(buildArgs) > 0 { |
|
args = append(args, strings.Fields(buildArgs)...) |
|
} |
|
|
|
if verbose { |
|
fmt.Fprintf(output, "\t%s%s+ go %s%s%s\n", "\x1b[32m", "\x1b[1m", strings.Join(args, " "), "\x1b[21m", "\x1b[0m") |
|
} |
|
|
|
execmd := exec.Command("go", args...) |
|
execmd.Env = append(os.Environ(), envs...) |
|
execmd.Stdout = os.Stdout |
|
execmd.Stderr = os.Stderr |
|
execmd.Dir = thePath |
|
err = execmd.Run() |
|
if err != nil { |
|
beeLogger.Log.Fatal(err.Error()) |
|
} |
|
|
|
beeLogger.Log.Success("Build Successful!") |
|
} |
|
|
|
switch format { |
|
case "zip": |
|
default: |
|
format = "tar.gz" |
|
} |
|
|
|
outputN := appName + "." + format |
|
|
|
if outputP == "" || !path.IsAbs(outputP) { |
|
outputP = path.Join(curPath, outputP) |
|
} |
|
|
|
if _, err := os.Stat(outputP); err != nil { |
|
err = os.MkdirAll(outputP, 0755) |
|
if err != nil { |
|
beeLogger.Log.Fatal(err.Error()) |
|
} |
|
} |
|
|
|
outputP = path.Join(outputP, outputN) |
|
|
|
var exp, exs []string |
|
for _, p := range strings.Split(excludeP, ":") { |
|
if len(p) > 0 { |
|
exp = append(exp, p) |
|
} |
|
} |
|
for _, p := range strings.Split(excludeS, ":") { |
|
if len(p) > 0 { |
|
exs = append(exs, p) |
|
} |
|
} |
|
|
|
var exr []*regexp.Regexp |
|
for _, r := range excludeR { |
|
if len(r) > 0 { |
|
if re, err := regexp.Compile(r); err != nil { |
|
beeLogger.Log.Fatal(err.Error()) |
|
} else { |
|
exr = append(exr, re) |
|
} |
|
} |
|
} |
|
|
|
beeLogger.Log.Infof("Writing to output: %s", outputP) |
|
|
|
err = packDirectory(output, exp, exs, exr, tmpdir, thePath) |
|
if err != nil { |
|
beeLogger.Log.Fatal(err.Error()) |
|
} |
|
|
|
beeLogger.Log.Success("Application packed!") |
|
return 0 |
|
}
|
|
|