plugeth/javascript/javascript_runtime.go

256 lines
5.7 KiB
Go
Raw Normal View History

package javascript
2014-05-15 18:45:19 +00:00
import (
"fmt"
2014-08-06 07:53:12 +00:00
"io/ioutil"
"os"
"path"
"path/filepath"
2014-10-31 13:20:11 +00:00
"github.com/ethereum/go-ethereum/cmd/utils"
2014-12-04 09:28:02 +00:00
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/eth"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/event"
2014-10-31 11:56:05 +00:00
"github.com/ethereum/go-ethereum/logger"
2014-10-31 13:43:14 +00:00
"github.com/ethereum/go-ethereum/state"
2014-10-31 13:30:08 +00:00
"github.com/ethereum/go-ethereum/xeth"
"github.com/obscuren/otto"
2014-05-15 18:45:19 +00:00
)
2014-10-31 11:56:05 +00:00
var jsrelogger = logger.NewLogger("JSRE")
2014-06-23 10:39:09 +00:00
2014-05-17 13:15:46 +00:00
type JSRE struct {
2014-05-19 10:15:03 +00:00
ethereum *eth.Ethereum
Vm *otto.Otto
2015-01-28 17:35:49 +00:00
pipe *xeth.XEth
2014-05-19 10:15:03 +00:00
events event.Subscription
2014-05-19 10:15:03 +00:00
objectCb map[string][]otto.Value
2014-05-15 18:45:19 +00:00
}
func (jsre *JSRE) LoadExtFile(path string) {
result, err := ioutil.ReadFile(path)
if err == nil {
jsre.Vm.Run(result)
} else {
jsrelogger.Infoln("Could not load file:", path)
}
}
func (jsre *JSRE) LoadIntFile(file string) {
assetPath := path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "cmd", "mist", "assets", "ext")
jsre.LoadExtFile(path.Join(assetPath, file))
}
2014-05-17 13:15:46 +00:00
func NewJSRE(ethereum *eth.Ethereum) *JSRE {
2014-05-19 10:15:03 +00:00
re := &JSRE{
ethereum,
otto.New(),
2015-01-28 17:35:49 +00:00
xeth.New(ethereum),
2014-10-14 17:38:38 +00:00
nil,
2014-05-19 10:15:03 +00:00
make(map[string][]otto.Value),
}
2014-05-19 14:32:45 +00:00
// Init the JS lib
re.Vm.Run(jsLib)
2014-05-19 14:32:45 +00:00
// Load extra javascript files
re.LoadIntFile("string.js")
re.LoadIntFile("big.js")
// Subscribe to events
2014-10-14 17:38:38 +00:00
mux := ethereum.EventMux()
2014-12-04 09:28:02 +00:00
re.events = mux.Subscribe(core.NewBlockEvent{})
// We have to make sure that, whoever calls this, calls "Stop"
go re.mainLoop()
2014-08-15 23:38:24 +00:00
re.Bind("eth", &JSEthereum{re.pipe, re.Vm, ethereum})
2014-05-19 10:15:03 +00:00
2014-05-20 10:48:34 +00:00
re.initStdFuncs()
2014-05-19 10:15:03 +00:00
2014-06-23 10:39:09 +00:00
jsrelogger.Infoln("started")
2014-05-20 10:48:34 +00:00
return re
}
2014-05-19 10:15:03 +00:00
2014-05-20 10:48:34 +00:00
func (self *JSRE) Bind(name string, v interface{}) {
self.Vm.Set(name, v)
2014-05-20 10:48:34 +00:00
}
2014-05-17 13:15:46 +00:00
2014-05-20 10:48:34 +00:00
func (self *JSRE) Run(code string) (otto.Value, error) {
return self.Vm.Run(code)
2014-05-17 13:15:46 +00:00
}
2014-05-20 17:28:48 +00:00
func (self *JSRE) Require(file string) error {
if len(filepath.Ext(file)) == 0 {
file += ".js"
}
fh, err := os.Open(file)
if err != nil {
return err
}
content, _ := ioutil.ReadAll(fh)
self.Run("exports = {};(function() {" + string(content) + "})();")
return nil
}
2014-05-19 10:15:03 +00:00
func (self *JSRE) Stop() {
2014-10-14 17:38:38 +00:00
self.events.Unsubscribe()
2014-06-23 10:39:09 +00:00
jsrelogger.Infoln("stopped")
2014-05-19 10:15:03 +00:00
}
func (self *JSRE) mainLoop() {
2014-10-14 17:38:38 +00:00
for _ = range self.events.Chan() {
2014-05-19 10:15:03 +00:00
}
}
2014-05-20 10:48:34 +00:00
func (self *JSRE) initStdFuncs() {
t, _ := self.Vm.Get("eth")
2014-05-20 10:48:34 +00:00
eth := t.Object()
2014-05-20 17:28:48 +00:00
eth.Set("watch", self.watch)
eth.Set("addPeer", self.addPeer)
2014-05-20 20:12:42 +00:00
eth.Set("require", self.require)
2014-05-21 22:25:48 +00:00
eth.Set("stopMining", self.stopMining)
eth.Set("startMining", self.startMining)
2014-06-24 07:36:05 +00:00
eth.Set("execBlock", self.execBlock)
2014-08-06 07:53:12 +00:00
eth.Set("dump", self.dump)
2014-12-17 11:57:35 +00:00
eth.Set("export", self.export)
2014-05-20 17:28:48 +00:00
}
/*
* The following methods are natively implemented javascript functions
*/
2014-08-06 07:53:12 +00:00
func (self *JSRE) dump(call otto.FunctionCall) otto.Value {
2015-01-07 12:17:48 +00:00
var block *types.Block
2014-08-06 07:53:12 +00:00
if len(call.ArgumentList) > 0 {
if call.Argument(0).IsNumber() {
num, _ := call.Argument(0).ToInteger()
2014-10-20 10:03:31 +00:00
block = self.ethereum.ChainManager().GetBlockByNumber(uint64(num))
2014-08-06 07:53:12 +00:00
} else if call.Argument(0).IsString() {
hash, _ := call.Argument(0).ToString()
2014-10-20 10:03:31 +00:00
block = self.ethereum.ChainManager().GetBlock(ethutil.Hex2Bytes(hash))
2014-08-06 07:53:12 +00:00
} else {
fmt.Println("invalid argument for dump. Either hex string or number")
}
if block == nil {
fmt.Println("block not found")
return otto.UndefinedValue()
}
} else {
2015-01-07 12:17:48 +00:00
block = self.ethereum.ChainManager().CurrentBlock()
2014-08-06 07:53:12 +00:00
}
2015-01-07 12:17:48 +00:00
statedb := state.New(block.Root(), self.ethereum.Db())
v, _ := self.Vm.ToValue(statedb.Dump())
2014-08-06 07:53:12 +00:00
2014-08-06 08:05:34 +00:00
return v
2014-08-06 07:53:12 +00:00
}
2014-05-21 22:25:48 +00:00
func (self *JSRE) stopMining(call otto.FunctionCall) otto.Value {
v, _ := self.Vm.ToValue(utils.StopMining(self.ethereum))
2014-05-21 22:25:48 +00:00
return v
}
func (self *JSRE) startMining(call otto.FunctionCall) otto.Value {
v, _ := self.Vm.ToValue(utils.StartMining(self.ethereum))
2014-05-21 22:25:48 +00:00
return v
}
2014-05-20 17:28:48 +00:00
// eth.watch
2014-05-21 22:25:48 +00:00
func (self *JSRE) watch(call otto.FunctionCall) otto.Value {
2014-05-20 17:28:48 +00:00
addr, _ := call.Argument(0).ToString()
var storageAddr string
var cb otto.Value
var storageCallback bool
if len(call.ArgumentList) > 2 {
storageCallback = true
storageAddr, _ = call.Argument(1).ToString()
cb = call.Argument(2)
} else {
cb = call.Argument(1)
}
if storageCallback {
self.objectCb[addr+storageAddr] = append(self.objectCb[addr+storageAddr], cb)
2014-05-15 18:45:19 +00:00
2014-10-14 17:38:38 +00:00
// event := "storage:" + string(ethutil.Hex2Bytes(addr)) + ":" + string(ethutil.Hex2Bytes(storageAddr))
// self.ethereum.EventMux().Subscribe(event, self.changeChan)
2014-05-20 17:28:48 +00:00
} else {
2014-05-20 10:48:34 +00:00
self.objectCb[addr] = append(self.objectCb[addr], cb)
2014-05-15 18:45:19 +00:00
2014-10-14 17:38:38 +00:00
// event := "object:" + string(ethutil.Hex2Bytes(addr))
// self.ethereum.EventMux().Subscribe(event, self.changeChan)
2014-05-20 17:28:48 +00:00
}
return otto.UndefinedValue()
}
2014-05-15 20:15:14 +00:00
2014-05-20 17:28:48 +00:00
func (self *JSRE) addPeer(call otto.FunctionCall) otto.Value {
host, err := call.Argument(0).ToString()
if err != nil {
return otto.FalseValue()
}
self.ethereum.SuggestPeer(host)
2014-05-20 17:28:48 +00:00
return otto.TrueValue()
}
func (self *JSRE) require(call otto.FunctionCall) otto.Value {
file, err := call.Argument(0).ToString()
if err != nil {
2014-05-15 20:15:14 +00:00
return otto.UndefinedValue()
2014-05-20 17:28:48 +00:00
}
if err := self.Require(file); err != nil {
fmt.Println("err:", err)
return otto.UndefinedValue()
}
t, _ := self.Vm.Get("exports")
2014-05-15 20:15:14 +00:00
2014-05-20 17:28:48 +00:00
return t
2014-05-15 18:45:19 +00:00
}
func (self *JSRE) execBlock(call otto.FunctionCall) otto.Value {
hash, err := call.Argument(0).ToString()
if err != nil {
return otto.UndefinedValue()
}
2014-06-29 17:32:48 +00:00
err = utils.BlockDo(self.ethereum, ethutil.Hex2Bytes(hash))
if err != nil {
fmt.Println(err)
return otto.FalseValue()
}
return otto.TrueValue()
}
2014-12-17 11:57:35 +00:00
func (self *JSRE) export(call otto.FunctionCall) otto.Value {
fn, err := call.Argument(0).ToString()
if err != nil {
fmt.Println(err)
return otto.FalseValue()
}
data := self.ethereum.ChainManager().Export()
if err := ethutil.WriteFile(fn, data); err != nil {
fmt.Println(err)
return otto.FalseValue()
}
return otto.TrueValue()
}