aboutsummaryrefslogtreecommitdiffstats
path: root/cmd/utils
diff options
context:
space:
mode:
Diffstat (limited to 'cmd/utils')
-rw-r--r--cmd/utils/cmd.go327
-rw-r--r--cmd/utils/vm_env.go41
-rw-r--r--cmd/utils/websockets.go161
3 files changed, 529 insertions, 0 deletions
diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go
new file mode 100644
index 000000000..7ee41d042
--- /dev/null
+++ b/cmd/utils/cmd.go
@@ -0,0 +1,327 @@
+package utils
+
+import (
+ "fmt"
+ "io"
+ "log"
+ "os"
+ "os/signal"
+ "path"
+ "path/filepath"
+ "regexp"
+ "runtime"
+ "time"
+
+ "bitbucket.org/kardianos/osext"
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/ethminer"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/ethwire"
+ "github.com/ethereum/go-ethereum/logger"
+ "github.com/ethereum/go-ethereum/rpc"
+)
+
+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 AbsolutePath(Datadir string, filename string) string {
+ if path.IsAbs(filename) {
+ return filename
+ }
+ return path.Join(Datadir, filename)
+}
+
+func openLogFile(Datadir string, filename string) *os.File {
+ path := 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?", r)
+ }
+ }
+ return r == "y"
+}
+
+func DBSanityCheck(db ethutil.Database) error {
+ d, _ := db.Get([]byte("ProtocolVersion"))
+ protov := ethutil.NewValue(d).Uint()
+ if protov != eth.ProtocolVersion && protov != 0 {
+ return fmt.Errorf("Database version mismatch. Protocol(%d / %d). `rm -rf %s`", protov, eth.ProtocolVersion, ethutil.Config.ExecPath+"/database")
+ }
+
+ return nil
+}
+
+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 InitLogging(Datadir string, LogFile string, LogLevel int, DebugFile string) logger.LogSystem {
+ var writer io.Writer
+ if LogFile == "" {
+ writer = os.Stdout
+ } else {
+ writer = openLogFile(Datadir, LogFile)
+ }
+
+ sys := logger.NewStdLogSystem(writer, log.LstdFlags, logger.LogLevel(LogLevel))
+ logger.AddLogSystem(sys)
+ if DebugFile != "" {
+ writer = openLogFile(Datadir, DebugFile)
+ logger.AddLogSystem(logger.NewStdLogSystem(writer, log.LstdFlags, logger.DebugLevel))
+ }
+
+ return sys
+}
+
+func InitConfig(vmType int, ConfigFile string, Datadir string, EnvPrefix string) *ethutil.ConfigManager {
+ InitDataDir(Datadir)
+ cfg := ethutil.ReadConfig(ConfigFile, Datadir, EnvPrefix)
+ cfg.VmType = vmType
+
+ return cfg
+}
+
+func exit(err error) {
+ status := 0
+ if err != nil {
+ clilogger.Errorln("Fatal: ", err)
+ status = 1
+ }
+ logger.Flush()
+ os.Exit(status)
+}
+
+func NewDatabase() ethutil.Database {
+ db, err := ethdb.NewLDBDatabase("database")
+ if err != nil {
+ exit(err)
+ }
+ return db
+}
+
+func NewClientIdentity(clientIdentifier, version, customIdentifier string) *ethwire.SimpleClientIdentity {
+ clilogger.Infoln("identity created")
+ return ethwire.NewSimpleClientIdentity(clientIdentifier, version, customIdentifier)
+}
+
+func NewEthereum(db ethutil.Database, clientIdentity ethwire.ClientIdentity, keyManager *crypto.KeyManager, usePnp bool, OutboundPort string, MaxPeer int) *eth.Ethereum {
+ ethereum, err := eth.New(db, clientIdentity, keyManager, eth.CapDefault, usePnp)
+ if err != nil {
+ clilogger.Fatalln("eth start err:", err)
+ }
+ ethereum.Port = OutboundPort
+ ethereum.MaxPeers = MaxPeer
+ return ethereum
+}
+
+func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) {
+ clilogger.Infof("Starting %s", ethereum.ClientIdentity())
+ ethereum.Start(UseSeed)
+ RegisterInterrupt(func(sig os.Signal) {
+ ethereum.Stop()
+ logger.Flush()
+ })
+}
+
+func ShowGenesis(ethereum *eth.Ethereum) {
+ clilogger.Infoln(ethereum.ChainManager().Genesis())
+ exit(nil)
+}
+
+func NewKeyManager(KeyStore string, Datadir string, db ethutil.Database) *crypto.KeyManager {
+ var keyManager *crypto.KeyManager
+ switch {
+ case KeyStore == "db":
+ keyManager = crypto.NewDBKeyManager(db)
+ case KeyStore == "file":
+ keyManager = crypto.NewFileKeyManager(Datadir)
+ default:
+ exit(fmt.Errorf("unknown keystore type: %s", KeyStore))
+ }
+ return keyManager
+}
+
+func DefaultAssetPath() string {
+ var assetPath string
+ // If the current working directory is the go-ethereum dir
+ // assume a debug build and use the source directory as
+ // asset directory.
+ pwd, _ := os.Getwd()
+ if pwd == path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "cmd", "mist") {
+ assetPath = path.Join(pwd, "assets")
+ } else {
+ switch runtime.GOOS {
+ case "darwin":
+ // Get Binary Directory
+ exedir, _ := osext.ExecutableFolder()
+ assetPath = filepath.Join(exedir, "../Resources")
+ case "linux":
+ assetPath = "/usr/share/mist"
+ case "windows":
+ assetPath = "./assets"
+ default:
+ assetPath = "."
+ }
+ }
+ return assetPath
+}
+
+func KeyTasks(keyManager *crypto.KeyManager, KeyRing string, GenAddr bool, SecretFile string, ExportDir string, NonInteractive bool) {
+
+ var err error
+ switch {
+ case GenAddr:
+ if NonInteractive || confirm("This action overwrites your old private key.") {
+ err = keyManager.Init(KeyRing, 0, true)
+ }
+ exit(err)
+ case len(SecretFile) > 0:
+ SecretFile = ethutil.ExpandHomePath(SecretFile)
+
+ if NonInteractive || confirm("This action overwrites your old private key.") {
+ err = keyManager.InitFromSecretsFile(KeyRing, 0, SecretFile)
+ }
+ exit(err)
+ case len(ExportDir) > 0:
+ err = keyManager.Init(KeyRing, 0, false)
+ if err == nil {
+ err = keyManager.Export(ExportDir)
+ }
+ exit(err)
+ default:
+ // Creates a keypair if none exists
+ err = keyManager.Init(KeyRing, 0, false)
+ if err != nil {
+ exit(err)
+ }
+ }
+}
+
+func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
+ var err error
+ ethereum.RpcServer, err = rpc.NewJsonRpcServer(ethpipe.NewJSPipe(ethereum), RpcPort)
+ if err != nil {
+ clilogger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err)
+ } else {
+ go ethereum.RpcServer.Start()
+ }
+}
+
+var miner *ethminer.Miner
+
+func GetMiner() *ethminer.Miner {
+ return miner
+}
+
+func StartMining(ethereum *eth.Ethereum) bool {
+ if !ethereum.Mining {
+ ethereum.Mining = true
+ addr := ethereum.KeyManager().Address()
+
+ go func() {
+ clilogger.Infoln("Start mining")
+ if miner == nil {
+ miner = ethminer.NewDefaultMiner(addr, ethereum)
+ }
+ // Give it some time to connect with peers
+ time.Sleep(3 * time.Second)
+ for !ethereum.IsUpToDate() {
+ time.Sleep(5 * time.Second)
+ }
+ miner.Start()
+ }()
+ RegisterInterrupt(func(os.Signal) {
+ StopMining(ethereum)
+ })
+ return true
+ }
+ return false
+}
+
+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 {
+ if ethereum.Mining && miner != nil {
+ miner.Stop()
+ clilogger.Infoln("Stopped mining")
+ ethereum.Mining = false
+
+ return true
+ }
+
+ return false
+}
+
+// Replay block
+func BlockDo(ethereum *eth.Ethereum, hash []byte) error {
+ block := ethereum.ChainManager().GetBlock(hash)
+ if block == nil {
+ return fmt.Errorf("unknown block %x", hash)
+ }
+
+ parent := ethereum.ChainManager().GetBlock(block.PrevHash)
+
+ _, err := ethereum.StateManager().ApplyDiff(parent.State(), parent, block)
+ if err != nil {
+ return err
+ }
+
+ return nil
+
+}
diff --git a/cmd/utils/vm_env.go b/cmd/utils/vm_env.go
new file mode 100644
index 000000000..0a7b589ee
--- /dev/null
+++ b/cmd/utils/vm_env.go
@@ -0,0 +1,41 @@
+package utils
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/chain"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/vm"
+)
+
+type VMEnv struct {
+ state *ethstate.State
+ block *chain.Block
+
+ transactor []byte
+ value *big.Int
+}
+
+func NewEnv(state *ethstate.State, block *chain.Block, transactor []byte, value *big.Int) *VMEnv {
+ return &VMEnv{
+ state: state,
+ block: block,
+ transactor: transactor,
+ value: value,
+ }
+}
+
+func (self *VMEnv) Origin() []byte { return self.transactor }
+func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
+func (self *VMEnv) PrevHash() []byte { return self.block.PrevHash }
+func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase }
+func (self *VMEnv) Time() int64 { return self.block.Time }
+func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty }
+func (self *VMEnv) BlockHash() []byte { return self.block.Hash() }
+func (self *VMEnv) Value() *big.Int { return self.value }
+func (self *VMEnv) State() *ethstate.State { return self.state }
+func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit }
+func (self *VMEnv) AddLog(ethstate.Log) {}
+func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
+ return vm.Transfer(from, to, amount)
+}
diff --git a/cmd/utils/websockets.go b/cmd/utils/websockets.go
new file mode 100644
index 000000000..7bda805ac
--- /dev/null
+++ b/cmd/utils/websockets.go
@@ -0,0 +1,161 @@
+package utils
+
+import (
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/websocket"
+)
+
+func args(v ...interface{}) []interface{} {
+ return v
+}
+
+type WebSocketServer struct {
+ ethereum *eth.Ethereum
+ filterCallbacks map[int][]int
+}
+
+func NewWebSocketServer(eth *eth.Ethereum) *WebSocketServer {
+ return &WebSocketServer{eth, make(map[int][]int)}
+}
+
+func (self *WebSocketServer) Serv() {
+ pipe := ethpipe.NewJSPipe(self.ethereum)
+
+ wsServ := websocket.NewServer("/eth", ":40404")
+ wsServ.MessageFunc(func(c *websocket.Client, msg *websocket.Message) {
+ switch msg.Call {
+ case "compile":
+ data := ethutil.NewValue(msg.Args)
+ bcode, err := ethutil.Compile(data.Get(0).Str(), false)
+ if err != nil {
+ c.Write(args(nil, err.Error()), msg.Seed)
+ }
+
+ code := ethutil.Bytes2Hex(bcode)
+ c.Write(args(code, nil), msg.Seed)
+ case "getBlockByNumber":
+ args := msg.Arguments()
+
+ block := pipe.BlockByNumber(int32(args.Get(0).Uint()))
+ c.Write(block, msg.Seed)
+
+ case "getKey":
+ c.Write(pipe.Key().PrivateKey, msg.Seed)
+ case "transact":
+ if mp, ok := msg.Args[0].(map[string]interface{}); ok {
+ object := mapToTxParams(mp)
+ c.Write(
+ args(pipe.Transact(object["from"], object["to"], object["value"], object["gas"], object["gasPrice"], object["data"])),
+ msg.Seed,
+ )
+
+ }
+ case "getCoinBase":
+ c.Write(pipe.CoinBase(), msg.Seed)
+
+ case "getIsListening":
+ c.Write(pipe.IsListening(), msg.Seed)
+
+ case "getIsMining":
+ c.Write(pipe.IsMining(), msg.Seed)
+
+ case "getPeerCoint":
+ c.Write(pipe.PeerCount(), msg.Seed)
+
+ case "getCountAt":
+ args := msg.Arguments()
+
+ c.Write(pipe.TxCountAt(args.Get(0).Str()), msg.Seed)
+
+ case "getCodeAt":
+ args := msg.Arguments()
+
+ c.Write(len(pipe.CodeAt(args.Get(0).Str())), msg.Seed)
+
+ case "getBlockByHash":
+ args := msg.Arguments()
+
+ c.Write(pipe.BlockByHash(args.Get(0).Str()), msg.Seed)
+
+ case "getStorageAt":
+ args := msg.Arguments()
+
+ c.Write(pipe.StorageAt(args.Get(0).Str(), args.Get(1).Str()), msg.Seed)
+
+ case "getBalanceAt":
+ args := msg.Arguments()
+
+ c.Write(pipe.BalanceAt(args.Get(0).Str()), msg.Seed)
+
+ case "getSecretToAddress":
+ args := msg.Arguments()
+
+ c.Write(pipe.SecretToAddress(args.Get(0).Str()), msg.Seed)
+
+ case "newFilter":
+ case "newFilterString":
+ case "messages":
+ // TODO
+ }
+
+ })
+
+ wsServ.Listen()
+}
+
+func StartWebSockets(eth *eth.Ethereum) {
+ sock := NewWebSocketServer(eth)
+ go sock.Serv()
+}
+
+// TODO This is starting to become a generic method. Move to utils
+func mapToTxParams(object map[string]interface{}) map[string]string {
+ // Default values
+ if object["from"] == nil {
+ object["from"] = ""
+ }
+ if object["to"] == nil {
+ object["to"] = ""
+ }
+ if object["value"] == nil {
+ object["value"] = ""
+ }
+ if object["gas"] == nil {
+ object["gas"] = ""
+ }
+ if object["gasPrice"] == nil {
+ object["gasPrice"] = ""
+ }
+
+ var dataStr string
+ var data []string
+ if str, ok := object["data"].(string); ok {
+ data = []string{str}
+ }
+
+ for _, str := range data {
+ if ethutil.IsHex(str) {
+ str = str[2:]
+
+ if len(str) != 64 {
+ str = ethutil.LeftPadString(str, 64)
+ }
+ } else {
+ str = ethutil.Bytes2Hex(ethutil.LeftPadBytes(ethutil.Big(str).Bytes(), 32))
+ }
+
+ dataStr += str
+ }
+ object["data"] = dataStr
+
+ conv := make(map[string]string)
+ for key, value := range object {
+ if v, ok := value.(string); ok {
+ conv[key] = v
+ }
+ }
+
+ return conv
+}
generated by cgit (git 2.34.1) at 2024-11-14 10:06:19 +0800