plugeth/cmd/utils/cmd.go

227 lines
5.3 KiB
Go
Raw Normal View History

2015-01-06 11:13:57 +00:00
/*
This file is part of go-ethereum
go-ethereum is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
go-ethereum 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @authors
* Jeffrey Wilcke <i@jev.io>
* Viktor Tron <viktor@ethdev.com>
*/
package utils
import (
2015-05-18 17:24:30 +00:00
"bufio"
2014-06-26 17:41:36 +00:00
"fmt"
"io"
"os"
"os/signal"
2014-08-15 11:16:07 +00:00
"regexp"
2015-05-18 17:24:30 +00:00
"strings"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core"
2014-12-23 14:37:03 +00:00
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/eth"
2014-10-31 11:56:05 +00:00
"github.com/ethereum/go-ethereum/logger"
2015-04-07 12:57:04 +00:00
"github.com/ethereum/go-ethereum/logger/glog"
2014-12-23 14:37:03 +00:00
"github.com/ethereum/go-ethereum/rlp"
2015-05-18 17:24:30 +00:00
"github.com/peterh/liner"
)
2014-06-26 09:47:45 +00:00
var interruptCallbacks = []func(os.Signal){}
2014-06-26 09:47:45 +00:00
// Register interrupt handlers callbacks
func RegisterInterrupt(cb func(os.Signal)) {
2014-06-26 17:41:36 +00:00
interruptCallbacks = append(interruptCallbacks, cb)
2014-06-26 09:47:45 +00:00
}
// go routine that call interrupt handlers in order of registering
func HandleInterrupt() {
2014-06-26 17:41:36 +00:00
c := make(chan os.Signal, 1)
go func() {
signal.Notify(c, os.Interrupt)
for sig := range c {
2015-04-07 12:57:04 +00:00
glog.V(logger.Error).Infof("Shutting down (%v) ... \n", sig)
2014-06-26 17:41:36 +00:00
RunInterruptCallbacks(sig)
}
}()
}
func RunInterruptCallbacks(sig os.Signal) {
2014-06-26 17:41:36 +00:00
for _, cb := range interruptCallbacks {
cb(sig)
}
}
2014-06-26 17:41:36 +00:00
func openLogFile(Datadir string, filename string) *os.File {
2015-03-16 10:27:38 +00:00
path := common.AbsolutePath(Datadir, filename)
2014-06-26 17:41:36 +00:00
file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
panic(fmt.Sprintf("error opening log file '%s': %v", filename, err))
}
return file
}
2015-05-18 17:24:30 +00:00
func PromptConfirm(prompt string) (bool, error) {
var (
input string
err error
)
prompt = prompt + " [y/N] "
if liner.TerminalSupported() {
lr := liner.NewLiner()
defer lr.Close()
input, err = lr.Prompt(prompt)
} else {
fmt.Print(prompt)
input, err = bufio.NewReader(os.Stdin).ReadString('\n')
fmt.Println()
}
if len(input) > 0 && strings.ToUpper(input[:1]) == "Y" {
return true, nil
} else {
return false, nil
}
return false, err
}
func PromptPassword(prompt string, warnTerm bool) (string, error) {
if liner.TerminalSupported() {
lr := liner.NewLiner()
defer lr.Close()
return lr.PasswordPrompt(prompt)
}
if warnTerm {
fmt.Println("!! Unsupported terminal, password will be echoed.")
}
fmt.Print(prompt)
input, err := bufio.NewReader(os.Stdin).ReadString('\n')
fmt.Println()
return input, err
}
2015-01-04 13:20:16 +00:00
func initDataDir(Datadir string) {
2014-06-26 17:41:36 +00:00
_, err := os.Stat(Datadir)
if err != nil {
if os.IsNotExist(err) {
fmt.Printf("Data directory '%s' doesn't exist, creating it\n", Datadir)
2014-06-26 17:41:36 +00:00
os.Mkdir(Datadir, 0777)
}
}
}
// Fatalf formats a message to standard output and exits the program.
func Fatalf(format string, args ...interface{}) {
fmt.Fprintf(os.Stderr, "Fatal: "+format+"\n", args...)
fmt.Fprintf(os.Stdout, "Fatal: "+format+"\n", args...)
logger.Flush()
os.Exit(1)
}
func StartEthereum(ethereum *eth.Ethereum) {
glog.V(logger.Info).Infoln("Starting", ethereum.Name())
if err := ethereum.Start(); err != nil {
Fatalf("Error starting Ethereum: %v", err)
2015-01-05 16:12:52 +00:00
}
2014-06-26 17:41:36 +00:00
RegisterInterrupt(func(sig os.Signal) {
ethereum.Stop()
2014-10-31 11:56:05 +00:00
logger.Flush()
2014-06-26 17:41:36 +00:00
})
}
2014-05-21 22:25:48 +00:00
func StartEthereumForTest(ethereum *eth.Ethereum) {
2015-04-07 12:57:04 +00:00
glog.V(logger.Info).Infoln("Starting ", ethereum.Name())
ethereum.StartForTest()
RegisterInterrupt(func(sig os.Signal) {
ethereum.Stop()
logger.Flush()
})
}
2014-08-15 11:16:07 +00:00
func FormatTransactionData(data string) []byte {
2015-03-16 10:27:38 +00:00
d := common.StringToByteFunc(data, func(s string) (ret []byte) {
2014-08-15 11:16:07 +00:00
slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000)
for _, dataItem := range slice {
2015-03-16 10:27:38 +00:00
d := common.FormatData(dataItem)
2014-08-15 11:16:07 +00:00
ret = append(ret, d...)
}
return
})
return d
}
func ImportChain(chainmgr *core.ChainManager, fn string) error {
fmt.Printf("importing blockchain '%s'\n", fn)
2014-12-23 14:37:03 +00:00
fh, err := os.OpenFile(fn, os.O_RDONLY, os.ModePerm)
if err != nil {
return err
}
defer fh.Close()
chainmgr.Reset()
stream := rlp.NewStream(fh, 0)
var i, n int
batchSize := 2500
blocks := make(types.Blocks, batchSize)
for ; ; i++ {
var b types.Block
if err := stream.Decode(&b); err == io.EOF {
break
} else if err != nil {
return fmt.Errorf("at block %d: %v", i, err)
}
blocks[n] = &b
n++
if n == batchSize {
if _, err := chainmgr.InsertChain(blocks); err != nil {
return fmt.Errorf("invalid block %v", err)
}
n = 0
blocks = make(types.Blocks, batchSize)
}
}
if n > 0 {
if _, err := chainmgr.InsertChain(blocks[:n]); err != nil {
return fmt.Errorf("invalid block %v", err)
}
2014-12-23 14:37:03 +00:00
}
fmt.Printf("imported %d blocks\n", i)
2014-12-23 14:37:03 +00:00
return nil
}
func ExportChain(chainmgr *core.ChainManager, fn string) error {
fmt.Printf("exporting blockchain '%s'\n", fn)
fh, err := os.OpenFile(fn, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
if err != nil {
return err
}
defer fh.Close()
if err := chainmgr.Export(fh); err != nil {
return err
}
fmt.Printf("exported blockchain\n")
return nil
}