plugeth/cmd/utils/cmd.go

276 lines
6.5 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 (
2014-06-26 17:41:36 +00:00
"fmt"
"os"
"os/signal"
2014-08-15 11:16:07 +00:00
"regexp"
2014-12-23 14:37:03 +00:00
"github.com/ethereum/go-ethereum/core/types"
2014-10-31 11:37:43 +00:00
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/eth"
"github.com/ethereum/go-ethereum/ethutil"
2014-10-31 11:56:05 +00:00
"github.com/ethereum/go-ethereum/logger"
2014-10-31 13:56:42 +00:00
"github.com/ethereum/go-ethereum/miner"
2014-12-23 14:37:03 +00:00
"github.com/ethereum/go-ethereum/rlp"
rpchttp "github.com/ethereum/go-ethereum/rpc/http"
rpcws "github.com/ethereum/go-ethereum/rpc/ws"
2015-01-07 12:17:48 +00:00
"github.com/ethereum/go-ethereum/state"
2014-10-31 13:30:08 +00:00
"github.com/ethereum/go-ethereum/xeth"
)
2014-10-31 11:56:05 +00:00
var clilogger = logger.NewLogger("CLI")
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 {
2014-10-31 11:56:05 +00:00
clilogger.Errorf("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-01-04 13:20:16 +00:00
path := ethutil.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
}
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 {
2015-01-04 13:20:16 +00:00
fmt.Printf("Yes or no? (%s)", r)
2014-06-26 17:41:36 +00:00
}
}
return r == "y"
}
2014-05-21 22:25:48 +00:00
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)
}
}
}
2014-10-14 09:49:15 +00:00
func InitConfig(vmType int, ConfigFile string, Datadir string, EnvPrefix string) *ethutil.ConfigManager {
2015-01-04 13:20:16 +00:00
initDataDir(Datadir)
2014-10-14 09:49:15 +00:00
cfg := ethutil.ReadConfig(ConfigFile, Datadir, EnvPrefix)
cfg.VmType = vmType
return cfg
}
func exit(err error) {
status := 0
if err != nil {
2014-10-31 11:56:05 +00:00
clilogger.Errorln("Fatal: ", err)
status = 1
}
2014-10-31 11:56:05 +00:00
logger.Flush()
2014-06-26 17:41:36 +00:00
os.Exit(status)
}
2014-05-21 22:25:48 +00:00
func StartEthereum(ethereum *eth.Ethereum) {
clilogger.Infoln("Starting ", ethereum.Name())
if err := ethereum.Start(); err != nil {
2015-01-05 16:12:52 +00:00
exit(err)
}
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
2014-10-31 11:37:43 +00:00
func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, SecretFile string, ExportDir string, NonInteractive bool) {
var err error
2014-06-26 17:41:36 +00:00
switch {
case GenAddr:
if NonInteractive || confirm("This action overwrites your old private key.") {
err = keyManager.Init(KeyRing, 0, true)
2014-06-26 17:41:36 +00:00
}
exit(err)
case len(SecretFile) > 0:
2014-07-01 18:10:38 +00:00
SecretFile = ethutil.ExpandHomePath(SecretFile)
2014-06-26 17:41:36 +00:00
if NonInteractive || confirm("This action overwrites your old private key.") {
err = keyManager.InitFromSecretsFile(KeyRing, 0, SecretFile)
2014-06-26 17:41:36 +00:00
}
exit(err)
case len(ExportDir) > 0:
err = keyManager.Init(KeyRing, 0, false)
if err == nil {
err = keyManager.Export(ExportDir)
}
exit(err)
2014-06-26 17:41:36 +00:00
default:
// Creates a keypair if none exists
err = keyManager.Init(KeyRing, 0, false)
if err != nil {
exit(err)
}
2014-06-26 17:41:36 +00:00
}
clilogger.Infof("Main address %x\n", keyManager.Address())
}
2014-05-21 22:25:48 +00:00
func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
2014-06-26 17:41:36 +00:00
var err error
2015-01-28 17:35:49 +00:00
ethereum.RpcServer, err = rpchttp.NewRpcHttpServer(xeth.New(ethereum), RpcPort)
2014-06-26 17:41:36 +00:00
if err != nil {
2014-10-31 11:56:05 +00:00
clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
2014-06-26 17:41:36 +00:00
} else {
go ethereum.RpcServer.Start()
}
2014-05-21 22:25:48 +00:00
}
func StartWebSockets(eth *eth.Ethereum, wsPort int) {
2015-01-20 19:40:24 +00:00
clilogger.Infoln("Starting WebSockets")
var err error
2015-02-02 13:37:44 +00:00
eth.WsServer, err = rpcws.NewWebSocketServer(xeth.New(eth), wsPort)
if err != nil {
clilogger.Errorf("Could not start RPC interface (port %v): %v", wsPort, err)
} else {
go eth.WsServer.Start()
}
2015-01-20 19:40:24 +00:00
}
2014-10-31 13:56:42 +00:00
var gminer *miner.Miner
2014-05-21 22:25:48 +00:00
2014-10-31 13:56:42 +00:00
func GetMiner() *miner.Miner {
return gminer
2014-07-18 10:01:26 +00:00
}
2014-05-21 22:25:48 +00:00
func StartMining(ethereum *eth.Ethereum) bool {
2014-06-26 17:41:36 +00:00
if !ethereum.Mining {
ethereum.Mining = true
addr := ethereum.KeyManager().Address()
2014-06-26 17:41:36 +00:00
go func() {
2014-10-31 11:56:05 +00:00
clilogger.Infoln("Start mining")
2014-10-31 13:56:42 +00:00
if gminer == nil {
gminer = miner.New(addr, ethereum, 4)
}
2014-10-31 13:56:42 +00:00
gminer.Start()
2014-06-26 17:41:36 +00:00
}()
RegisterInterrupt(func(os.Signal) {
StopMining(ethereum)
})
return true
}
return false
}
2014-05-21 22:25:48 +00:00
2014-08-15 11:16:07 +00:00
func FormatTransactionData(data string) []byte {
d := ethutil.StringToByteFunc(data, func(s string) (ret []byte) {
slice := regexp.MustCompile("\\n|\\s").Split(s, 1000000000)
for _, dataItem := range slice {
d := ethutil.FormatData(dataItem)
ret = append(ret, d...)
}
return
})
return d
}
func StopMining(ethereum *eth.Ethereum) bool {
2014-10-31 13:56:42 +00:00
if ethereum.Mining && gminer != nil {
gminer.Stop()
2014-10-31 11:56:05 +00:00
clilogger.Infoln("Stopped mining")
2014-06-26 17:41:36 +00:00
ethereum.Mining = false
2014-07-18 11:49:52 +00:00
2014-06-26 17:41:36 +00:00
return true
}
2014-07-18 11:49:52 +00:00
2014-06-26 17:41:36 +00:00
return false
2014-05-21 22:25:48 +00:00
}
2014-06-25 07:47:11 +00:00
// Replay block
func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
2014-10-20 10:03:31 +00:00
block := ethereum.ChainManager().GetBlock(hash)
2014-06-25 07:47:11 +00:00
if block == nil {
return fmt.Errorf("unknown block %x", hash)
}
parent := ethereum.ChainManager().GetBlock(block.ParentHash())
2014-06-25 07:47:11 +00:00
2015-01-07 12:17:48 +00:00
statedb := state.New(parent.Root(), ethereum.Db())
_, err := ethereum.BlockProcessor().TransitionState(statedb, parent, block, true)
2014-06-25 07:47:11 +00:00
if err != nil {
return err
}
return nil
}
2014-12-23 14:37:03 +00:00
func ImportChain(ethereum *eth.Ethereum, fn string) error {
2014-12-23 17:35:36 +00:00
clilogger.Infof("importing chain '%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()
var chain types.Blocks
if err := rlp.Decode(fh, &chain); err != nil {
return err
}
ethereum.ChainManager().Reset()
if err := ethereum.ChainManager().InsertChain(chain); err != nil {
return err
}
clilogger.Infof("imported %d blocks\n", len(chain))
return nil
}