forked from cerc-io/plugeth
39b0b1a1a6
Most of these changes are related to the Go 1.13 changes to test binary flag handling. * cmd/geth: make attach tests more reliable This makes the test wait for the endpoint to come up by polling it instead of waiting for two seconds. * tests: fix test binary flags for Go 1.13 Calling flag.Parse during package initialization is prohibited as of Go 1.13 and causes test failures. Call it in TestMain instead. * crypto/ecies: remove useless -dump flag in tests * p2p/simulations: fix test binary flags for Go 1.13 Calling flag.Parse during package initialization is prohibited as of Go 1.13 and causes test failures. Call it in TestMain instead. * build: remove workaround for ./... vendor matching This workaround was necessary for Go 1.8. The Go 1.9 release changed the expansion rules to exclude vendored packages. * Makefile: use relative path for GOBIN This makes the "Run ./build/bin/..." line look nicer. * les: fix test binary flags for Go 1.13 Calling flag.Parse during package initialization is prohibited as of Go 1.13 and causes test failures. Call it in TestMain instead.
186 lines
5.3 KiB
Go
186 lines
5.3 KiB
Go
// Copyright 2016 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package build
|
|
|
|
import (
|
|
"bytes"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"path"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"text/template"
|
|
)
|
|
|
|
var DryRunFlag = flag.Bool("n", false, "dry run, don't execute commands")
|
|
|
|
// MustRun executes the given command and exits the host process for
|
|
// any error.
|
|
func MustRun(cmd *exec.Cmd) {
|
|
fmt.Println(">>>", strings.Join(cmd.Args, " "))
|
|
if !*DryRunFlag {
|
|
cmd.Stderr = os.Stderr
|
|
cmd.Stdout = os.Stdout
|
|
if err := cmd.Run(); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func MustRunCommand(cmd string, args ...string) {
|
|
MustRun(exec.Command(cmd, args...))
|
|
}
|
|
|
|
// GOPATH returns the value that the GOPATH environment
|
|
// variable should be set to.
|
|
func GOPATH() string {
|
|
if os.Getenv("GOPATH") == "" {
|
|
log.Fatal("GOPATH is not set")
|
|
}
|
|
return os.Getenv("GOPATH")
|
|
}
|
|
|
|
var warnedAboutGit bool
|
|
|
|
// RunGit runs a git subcommand and returns its output.
|
|
// The command must complete successfully.
|
|
func RunGit(args ...string) string {
|
|
cmd := exec.Command("git", args...)
|
|
var stdout, stderr bytes.Buffer
|
|
cmd.Stdout, cmd.Stderr = &stdout, &stderr
|
|
if err := cmd.Run(); err != nil {
|
|
if e, ok := err.(*exec.Error); ok && e.Err == exec.ErrNotFound {
|
|
if !warnedAboutGit {
|
|
log.Println("Warning: can't find 'git' in PATH")
|
|
warnedAboutGit = true
|
|
}
|
|
return ""
|
|
}
|
|
log.Fatal(strings.Join(cmd.Args, " "), ": ", err, "\n", stderr.String())
|
|
}
|
|
return strings.TrimSpace(stdout.String())
|
|
}
|
|
|
|
// readGitFile returns content of file in .git directory.
|
|
func readGitFile(file string) string {
|
|
content, err := ioutil.ReadFile(path.Join(".git", file))
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return strings.TrimSpace(string(content))
|
|
}
|
|
|
|
// Render renders the given template file into outputFile.
|
|
func Render(templateFile, outputFile string, outputPerm os.FileMode, x interface{}) {
|
|
tpl := template.Must(template.ParseFiles(templateFile))
|
|
render(tpl, outputFile, outputPerm, x)
|
|
}
|
|
|
|
// RenderString renders the given template string into outputFile.
|
|
func RenderString(templateContent, outputFile string, outputPerm os.FileMode, x interface{}) {
|
|
tpl := template.Must(template.New("").Parse(templateContent))
|
|
render(tpl, outputFile, outputPerm, x)
|
|
}
|
|
|
|
func render(tpl *template.Template, outputFile string, outputPerm os.FileMode, x interface{}) {
|
|
if err := os.MkdirAll(filepath.Dir(outputFile), 0755); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
out, err := os.OpenFile(outputFile, os.O_CREATE|os.O_WRONLY|os.O_EXCL, outputPerm)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
if err := tpl.Execute(out, x); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
if err := out.Close(); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// CopyFile copies a file.
|
|
func CopyFile(dst, src string, mode os.FileMode) {
|
|
if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
destFile, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, mode)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
defer destFile.Close()
|
|
|
|
srcFile, err := os.Open(src)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
defer srcFile.Close()
|
|
|
|
if _, err := io.Copy(destFile, srcFile); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// GoTool returns the command that runs a go tool. This uses go from GOROOT instead of PATH
|
|
// so that go commands executed by build use the same version of Go as the 'host' that runs
|
|
// build code. e.g.
|
|
//
|
|
// /usr/lib/go-1.12.1/bin/go run build/ci.go ...
|
|
//
|
|
// runs using go 1.12.1 and invokes go 1.12.1 tools from the same GOROOT. This is also important
|
|
// because runtime.Version checks on the host should match the tools that are run.
|
|
func GoTool(tool string, args ...string) *exec.Cmd {
|
|
args = append([]string{tool}, args...)
|
|
return exec.Command(filepath.Join(runtime.GOROOT(), "bin", "go"), args...)
|
|
}
|
|
|
|
// UploadSFTP uploads files to a remote host using the sftp command line tool.
|
|
// The destination host may be specified either as [user@]host[: or as a URI in
|
|
// the form sftp://[user@]host[:port].
|
|
func UploadSFTP(identityFile, host, dir string, files []string) error {
|
|
sftp := exec.Command("sftp")
|
|
sftp.Stdout = nil
|
|
sftp.Stderr = os.Stderr
|
|
if identityFile != "" {
|
|
sftp.Args = append(sftp.Args, "-i", identityFile)
|
|
}
|
|
sftp.Args = append(sftp.Args, host)
|
|
fmt.Println(">>>", strings.Join(sftp.Args, " "))
|
|
if *DryRunFlag {
|
|
return nil
|
|
}
|
|
|
|
stdin, err := sftp.StdinPipe()
|
|
if err != nil {
|
|
return fmt.Errorf("can't create stdin pipe for sftp: %v", err)
|
|
}
|
|
if err := sftp.Start(); err != nil {
|
|
return err
|
|
}
|
|
in := io.MultiWriter(stdin, os.Stdout)
|
|
for _, f := range files {
|
|
fmt.Fprintln(in, "put", f, path.Join(dir, filepath.Base(f)))
|
|
}
|
|
stdin.Close()
|
|
return sftp.Wait()
|
|
}
|