b5b83db450
This also changes the chain export format so there is no enclosing list around the blocks, which enables streaming export.
188 lines
4.4 KiB
Go
188 lines
4.4 KiB
Go
/*
|
|
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 (
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/signal"
|
|
"regexp"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/eth"
|
|
"github.com/ethereum/go-ethereum/logger"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
)
|
|
|
|
var clilogger = logger.NewLogger("CLI")
|
|
var interruptCallbacks = []func(os.Signal){}
|
|
|
|
// Register interrupt handlers callbacks
|
|
func RegisterInterrupt(cb func(os.Signal)) {
|
|
interruptCallbacks = append(interruptCallbacks, cb)
|
|
}
|
|
|
|
// go routine that call interrupt handlers in order of registering
|
|
func HandleInterrupt() {
|
|
c := make(chan os.Signal, 1)
|
|
go func() {
|
|
signal.Notify(c, os.Interrupt)
|
|
for sig := range c {
|
|
clilogger.Errorf("Shutting down (%v) ... \n", sig)
|
|
RunInterruptCallbacks(sig)
|
|
}
|
|
}()
|
|
}
|
|
|
|
func RunInterruptCallbacks(sig os.Signal) {
|
|
for _, cb := range interruptCallbacks {
|
|
cb(sig)
|
|
}
|
|
}
|
|
|
|
func openLogFile(Datadir string, filename string) *os.File {
|
|
path := common.AbsolutePath(Datadir, filename)
|
|
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
|
|
}
|
|
|
|
func confirm(message string) bool {
|
|
fmt.Println(message, "Are you sure? (y/n)")
|
|
var r string
|
|
fmt.Scanln(&r)
|
|
for ; ; fmt.Scanln(&r) {
|
|
if r == "n" || r == "y" {
|
|
break
|
|
} else {
|
|
fmt.Printf("Yes or no? (%s)", r)
|
|
}
|
|
}
|
|
return r == "y"
|
|
}
|
|
|
|
func initDataDir(Datadir string) {
|
|
_, err := os.Stat(Datadir)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
fmt.Printf("Data directory '%s' doesn't exist, creating it\n", Datadir)
|
|
os.Mkdir(Datadir, 0777)
|
|
}
|
|
}
|
|
}
|
|
|
|
func exit(err error) {
|
|
status := 0
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "Fatal:", err)
|
|
status = 1
|
|
}
|
|
logger.Flush()
|
|
os.Exit(status)
|
|
}
|
|
|
|
// 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...)
|
|
logger.Flush()
|
|
os.Exit(1)
|
|
}
|
|
|
|
func StartEthereum(ethereum *eth.Ethereum) {
|
|
clilogger.Infoln("Starting ", ethereum.Name())
|
|
if err := ethereum.Start(); err != nil {
|
|
exit(err)
|
|
}
|
|
RegisterInterrupt(func(sig os.Signal) {
|
|
ethereum.Stop()
|
|
logger.Flush()
|
|
})
|
|
}
|
|
|
|
func StartEthereumForTest(ethereum *eth.Ethereum) {
|
|
clilogger.Infoln("Starting ", ethereum.Name())
|
|
ethereum.StartForTest()
|
|
RegisterInterrupt(func(sig os.Signal) {
|
|
ethereum.Stop()
|
|
logger.Flush()
|
|
})
|
|
}
|
|
|
|
func FormatTransactionData(data string) []byte {
|
|
d := common.StringToByteFunc(data, func(s string) (ret []byte) {
|
|
slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000)
|
|
for _, dataItem := range slice {
|
|
d := common.FormatData(dataItem)
|
|
ret = append(ret, d...)
|
|
}
|
|
return
|
|
})
|
|
|
|
return d
|
|
}
|
|
|
|
func ImportChain(chainmgr *core.ChainManager, fn string) error {
|
|
fmt.Printf("importing blockchain '%s'\n", fn)
|
|
fh, err := os.OpenFile(fn, os.O_RDONLY, os.ModePerm)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer fh.Close()
|
|
|
|
chainmgr.Reset()
|
|
stream := rlp.NewStream(fh)
|
|
var i int
|
|
for ; ; i++ {
|
|
var b types.Block
|
|
err := stream.Decode(&b)
|
|
if err == io.EOF {
|
|
break
|
|
} else if err != nil {
|
|
return fmt.Errorf("at block %d: %v", i, err)
|
|
}
|
|
if err := chainmgr.InsertChain(types.Blocks{b}); err != nil {
|
|
return fmt.Errorf("invalid block %d: %v", i, err)
|
|
}
|
|
}
|
|
fmt.Printf("imported %d blocks\n", i)
|
|
return nil
|
|
}
|
|
|
|
func ExportChain(chainmgr *core.ChainManager, fn string) error {
|
|
fmt.Printf("exporting blockchain '%s'\n", fn)
|
|
fh, err := os.OpenFile(fn, 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
|
|
}
|