Ejemplo n.º 1
0
func (js *jsre) printBlock(call otto.FunctionCall) otto.Value {
	var block *types.Block
	if len(call.ArgumentList) > 0 {
		if call.Argument(0).IsNumber() {
			num, _ := call.Argument(0).ToInteger()
			block = js.ethereum.ChainManager().GetBlockByNumber(uint64(num))
		} else if call.Argument(0).IsString() {
			hash, _ := call.Argument(0).ToString()
			block = js.ethereum.ChainManager().GetBlock(common.HexToHash(hash))
		} else {
			fmt.Println("invalid argument for dump. Either hex string or number")
		}

	} else {
		block = js.ethereum.ChainManager().CurrentBlock()
	}
	if block == nil {
		fmt.Println("block not found")
		return otto.UndefinedValue()
	}

	fmt.Println(block)

	return otto.UndefinedValue()
}
Ejemplo n.º 2
0
// NewWriter adds a write method to the specified runtime that allows
// client code to write to the specified io.Writer.
//
// The client function created has the following syntax:
//
//     var response = writeMethodName(contentToWrite)
//
// Response object:
//
//     {
//       len: bytes_written,
//        error: error|undefined
//     }
func NewWriter(runtime *otto.Otto, methodName string, writer io.Writer) error {

	runtime.Set(methodName, func(call otto.FunctionCall) otto.Value {

		var data string
		var count int
		var err error
		var val otto.Value

		if data, err = call.Argument(0).ToString(); err == nil {
			if count, err = writer.Write([]byte(data)); err == nil {
				if val, err = makeMap(runtime, map[string]interface{}{"len": count}); err != nil {
					raiseError(runtime, "Failed to create output object: %s", err)
				} else {
					return val
				}
			}
		}

		if err != nil {
			if val, err := makeMap(runtime, map[string]interface{}{"len": 0, "error": err.Error()}); err != nil {
				raiseError(runtime, "Failed to create output object: %s", err)
				return otto.UndefinedValue()
			} else {
				return val
			}
		}

		return otto.UndefinedValue()

	})

	return nil
}
Ejemplo n.º 3
0
func toValue(vm *motto.Motto, value interface{}) otto.Value {
	var err error
	var val otto.Value
	switch n := value.(type) {
	case dict.Map, map[string]interface{}:
		bs, e := json.Marshal(n)
		if e != nil {
			err = e
			return otto.UndefinedValue()
		}
		object, oe := vm.Object("(" + string(bs) + ")")
		if oe != nil {
			err = oe
		} else {
			val = object.Value()
		}

	default:
		val, err = vm.ToValue(n)
	}

	if err != nil {
		log.Printf("Could not convert %v", err)
		return otto.UndefinedValue()
	}

	return val
}
Ejemplo n.º 4
0
func main() {
	if len(os.Args) != 2 {
		usage()
	}
	vm := motto.New()

	vm.Set("fib", func(call otto.FunctionCall) otto.Value {

		ret := fib(40)

		v, _ := otto.ToValue(ret)

		return v

	})

	vm.Set("XHR", func(call otto.FunctionCall) otto.Value {
		return otto.UndefinedValue()
	})
	vm.Set("XHR.prototype.hello", func(call otto.FunctionCall) otto.Value {
		return otto.UndefinedValue()
	})
	_, err := vm.Run(os.Args[1])
	fmt.Printf("%v", err)
}
Ejemplo n.º 5
0
func mkAssert(t *testing.T) func(otto.FunctionCall) otto.Value {
	return func(call otto.FunctionCall) otto.Value {
		name, err := call.Argument(0).ToString()
		if err != nil {
			t.Fatalf("Error getting name of assertion: %v", err)
		}
		t.Logf("RUN %v", name)

		got, err := call.Argument(1).Export()
		if err != nil {
			t.Errorf("Eval error on %v: %v", name, err)
			return otto.UndefinedValue()
		}
		exp, err := call.Argument(2).Export()
		if err != nil {
			t.Errorf("Comparison error on %v: %v", name, err)
			return otto.UndefinedValue()
		}

		if toInt(exp) != toInt(got) {
			t.Errorf("FAIL Expected %T(%v) for %v, got %T(%v)",
				exp, exp, name, got, got)
		} else {
			t.Logf("PASS %v", name)
		}
		return otto.UndefinedValue()
	}
}
Ejemplo n.º 6
0
func apiServiceCall(call otto.FunctionCall) otto.Value {
	svc := call.Argument(0).String()

	interfaceValue, err := call.Argument(1).Export()
	if err != nil {
		logrus.Errorf("Plugins: rules: javascript supplied invalid parameters")
		return otto.UndefinedValue()
	}
	params := interfaceValue.(map[string]interface{})

	future := service.CallService(svc, params)
	result := <-future.Result

	var res otto.Value

	if _, ok := result.(error); ok {
		res, err = otto.ToValue(result.(error).Error())
	} else {
		res, err = otto.ToValue(result)
	}
	if err != nil {
		logrus.Errorf("Plugins: rules: failed to convert service result to javascript")
		return otto.UndefinedValue()
	}
	return res
}
Ejemplo n.º 7
0
func NewExecutor(s stream.Stream) *Executor {
	e := &Executor{
		incomingScripts: make(chan string),
		outgoingMsgs:    make(chan string),
		incomingEvents:  make(chan IncomingEvent),
		eventHandlers:   make(map[string]map[string]otto.Value),
	}
	e.xmppStream = s
	e.vm = otto.New()

	send := func(call otto.FunctionCall) otto.Value {
		str, _ := call.Argument(0).ToString()
		e.outgoingMsgs <- str
		return otto.UndefinedValue()
	}

	addHandler := func(call otto.FunctionCall) otto.Value {
		evtName, err := call.Argument(0).ToString()
		handlerName, err := call.Argument(1).ToString()
		if err != nil {
			return otto.FalseValue()
		}
		val := call.Argument(2)
		if !val.IsFunction() {
			return otto.FalseValue()
		}
		handlers, ok := e.eventHandlers[evtName]
		if !ok {
			e.eventHandlers[evtName] = map[string]otto.Value{handlerName: val}
		} else {
			handlers[handlerName] = val
		}
		return otto.TrueValue()
	}

	listHandlers := func(call otto.FunctionCall) otto.Value {
		evtName, err := call.Argument(0).ToString()
		if err != nil {
			return otto.UndefinedValue()
		}
		list := []string{}
		for handlerName := range e.eventHandlers[evtName] {
			list = append(list, handlerName)
		}
		val, err := e.vm.ToValue(list)
		if err != nil {
			return otto.UndefinedValue()
		} else {
			return val
		}
	}

	chatLibrary, _ := e.vm.Object("Chat = {};")
	chatLibrary.Set("send", send)
	chatLibrary.Set("addEventHandler", addHandler)
	chatLibrary.Set("listEventHandlers", listHandlers)
	return e
}
Ejemplo n.º 8
0
func (js *jsre) verbosity(call otto.FunctionCall) otto.Value {
	v, err := call.Argument(0).ToInteger()
	if err != nil {
		fmt.Println(err)
		return otto.UndefinedValue()
	}

	glog.SetV(int(v))
	return otto.UndefinedValue()
}
Ejemplo n.º 9
0
func (js *jsre) backtrace(call otto.FunctionCall) otto.Value {
	tracestr, err := call.Argument(0).ToString()
	if err != nil {
		fmt.Println(err)
		return otto.UndefinedValue()
	}
	glog.GetTraceLocation().Set(tracestr)

	return otto.UndefinedValue()
}
Ejemplo n.º 10
0
func (self *context) CreateFile(call otto.FunctionCall) otto.Value {
	if len(call.ArgumentList) != 2 {
		return otto.UndefinedValue()
	}

	path, _ := call.Argument(0).ToString()
	val, _ := call.Argument(1).ToString()
	self.ctx.CreateFile(path, []byte(val))

	return otto.UndefinedValue()
}
Ejemplo n.º 11
0
func requireFromOtto(moduleName string, vm *otto.Otto) (otto.Value, error) {
	rawModule, errRequire := RequireModule(moduleName)
	if errRequire != nil {
		return otto.UndefinedValue(), errRequire
	}

	module, errConvert := vm.ToValue(rawModule)
	if errConvert != nil {
		return otto.UndefinedValue(), errConvert
	}

	return module, nil
}
Ejemplo n.º 12
0
Archivo: js.go Proyecto: steveyen/cbgb
func OttoFromGoArray(o *otto.Otto, arr []interface{}) (otto.Value, error) {
	ovarr, err := OttoFromGo(o, arr)
	if err != nil {
		return otto.UndefinedValue(),
			fmt.Errorf("could not convert arr, err: %v", err)
	}
	if ovarr.Class() != "Array" {
		return otto.UndefinedValue(),
			fmt.Errorf("expected ovarr to be array, got: %#v, class: %v, arr: %v",
				ovarr, ovarr.Class(), arr)
	}
	return ovarr, nil
}
Ejemplo n.º 13
0
func (v *View) GetViewMapFunction() (*ViewMapFunction, error) {
	if v.preparedViewMapFunction != nil {
		return v.preparedViewMapFunction, nil
	}

	if v.Map == "" {
		return nil, fmt.Errorf("view map function missing")
	}

	o := otto.New()
	mapf, err := OttoNewFunction(o, v.Map)
	if err != nil {
		return nil, fmt.Errorf("view map function error: %v", err)
	}

	emits := []*ViewRow{}
	var emitErr error

	o.Set("emit", func(call otto.FunctionCall) otto.Value {
		if len(call.ArgumentList) <= 0 {
			emitErr = fmt.Errorf("emit() invoked with no parameters")
			return otto.UndefinedValue()
		}
		var key, value interface{}
		key, emitErr = call.ArgumentList[0].Export()
		if emitErr != nil {
			return otto.UndefinedValue()
		}
		if len(call.ArgumentList) >= 2 {
			value, emitErr = call.ArgumentList[1].Export()
			if emitErr != nil {
				return otto.UndefinedValue()
			}
		}
		emits = append(emits, &ViewRow{Key: key, Value: value})
		return otto.UndefinedValue()
	})

	v.preparedViewMapFunction = &ViewMapFunction{
		otto: o,
		mapf: mapf,
		restartEmits: func() (resEmits []*ViewRow, resEmitErr error) {
			resEmits = emits
			resEmitErr = emitErr
			emits = []*ViewRow{}
			emitErr = nil
			return resEmits, resEmitErr
		},
	}
	return v.preparedViewMapFunction, nil
}
Ejemplo n.º 14
0
// RegisterMethodFileOpen registers a method that is capable of opening files.
//
// Response object:
//
//     {
//       ok: true|false,
//       reader: "readFile" // the method to use to read from the file
//     }
//
// To read the entire file into a variable:
//
//     // in Go...
//     RegisterMethodFileOpen(js, "openFile")
//
//     // in the script...
//     var file = openFile("filename"); // open the file
//     var read = eval(file.reader); // get the reader method
//     var close = eval(file.closer); // get the closer method
//
//     var fileContents = read(-1); // read everything
//     close(); // close the file
//
func RegisterMethodFileOpen(runtime *otto.Otto, methodName string) error {

	runtime.Set(methodName, func(call otto.FunctionCall) otto.Value {

		// check the arguments
		if len(call.ArgumentList) != 1 {
			raiseError(runtime, "%s takes 1 arguments: %s(filename)", methodName, methodName)
			return otto.UndefinedValue()
		}

		// get the arguments
		var filename string
		var err error
		if filename, err = call.Argument(0).ToString(); err != nil {
			raiseError(runtime, "%s first argument must be a string containing the filename", methodName)
			return otto.UndefinedValue()
		}

		// open the file
		var file io.ReadCloser
		if file, err = os.Open(filename); err != nil {
			raiseError(runtime, "Failed to open file '%s': %s", filename, err)
			return otto.UndefinedValue()
		}

		// add the reader
		var readerMethodName string = generateMethodName("fileRead")
		NewReader(runtime, readerMethodName, file)

		// add the closer
		var closerMethodName string = generateMethodName("fileClose")
		runtime.Set(closerMethodName, func(call otto.FunctionCall) otto.Value {
			if err := file.Close(); err != nil {
				raiseError(runtime, "Failed to close file '%s': %s", filename, err)
				return otto.FalseValue()
			}
			return otto.TrueValue()
		})

		var response otto.Value
		if response, err = makeMap(runtime, map[string]interface{}{"reader": readerMethodName, "closer": closerMethodName, "ok": true}); err != nil {
			raiseError(runtime, "%s failed to make response map.", methodName)
			return otto.UndefinedValue()
		}

		// done
		return response
	})

	return nil
}
Ejemplo n.º 15
0
func (self *context) Get(call otto.FunctionCall) otto.Value {
	if len(call.ArgumentList) != 1 {
		return otto.UndefinedValue()
	}

	key, _ := call.Argument(0).ToString()
	val := self.ctx.Get(key)

	if val != nil {
		return toValue(self.vm, val)
	}

	return otto.UndefinedValue()
}
Ejemplo n.º 16
0
// myIpAddress returns the IP address of the host machine.
func gopacMyIpAddress() otto.Value {
	hostname, err := os.Hostname()

	if err != nil {
		return otto.UndefinedValue()
	}

	address := gopacDnsResolve(hostname)

	if value, err := otto.ToValue(address); err == nil {
		return value
	}

	return otto.UndefinedValue()
}
Ejemplo n.º 17
0
func (js *jsre) setHead(call otto.FunctionCall) otto.Value {
	block, err := js.getBlock(call)
	if err != nil {
		fmt.Println(err)
		return otto.UndefinedValue()
	}

	if block == nil {
		fmt.Println("block not found")
		return otto.UndefinedValue()
	}

	js.ethereum.ChainManager().SetHead(block)
	return otto.UndefinedValue()
}
Ejemplo n.º 18
0
func (js *jsre) getBlockRlp(call otto.FunctionCall) otto.Value {
	block, err := js.getBlock(call)
	if err != nil {
		fmt.Println(err)
		return otto.UndefinedValue()
	}

	if block == nil {
		fmt.Println("block not found")
		return otto.UndefinedValue()
	}

	encoded, _ := rlp.EncodeToBytes(block)
	return js.re.ToVal(fmt.Sprintf("%x", encoded))
}
Ejemplo n.º 19
0
func (js *jsre) setExtra(call otto.FunctionCall) otto.Value {
	extra, err := call.Argument(0).ToString()
	if err != nil {
		fmt.Println(err)
		return otto.UndefinedValue()
	}

	if len(extra) > 1024 {
		fmt.Println("error: cannot exceed 1024 bytes")
		return otto.UndefinedValue()
	}

	js.ethereum.Miner().SetExtra([]byte(extra))
	return otto.UndefinedValue()
}
Ejemplo n.º 20
0
// stringToValue makes an otto.Value containing the specified string.
func stringToValue(message string) otto.Value {
	val, err := otto.ToValue(message)
	if err != nil {
		return otto.UndefinedValue()
	}
	return val
}
Ejemplo n.º 21
0
// Invokes the JS function. Not thread-safe! This is exposed for use by unit tests.
func (server *JSServer) DirectCallFunction(inputs []string) (interface{}, error) {
	if server.Before != nil {
		server.Before()
	}

	var result otto.Value
	var err error
	if server.fn.IsUndefined() {
		result = otto.UndefinedValue()
	} else {
		inputJS := make([]interface{}, len(inputs))
		for i, inputStr := range inputs {
			if inputStr == "" {
				inputJS[i] = otto.NullValue()
			} else {
				var err error
				inputJS[i], err = server.js.Object("x = " + inputStr)
				if err != nil {
					return nil, fmt.Errorf("Unparseable input %q: %s", inputStr, err)
				}
			}
		}
		result, err = server.fn.Call(server.fn, inputJS...)
	}
	if server.After != nil {
		return server.After(result, err)
	}
	return nil, err
}
Ejemplo n.º 22
0
func TestFetchWithHandlerParallel(t *testing.T) {
	m := http.NewServeMux()
	m.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("hello"))
	})

	vm := otto.New()
	l := loop.New(vm)

	if err := DefineWithHandler(vm, l, m); err != nil {
		panic(err)
	}

	ch := make(chan bool, 1)

	if err := vm.Set("__capture", func(c otto.FunctionCall) otto.Value {
		defer func() { ch <- true }()

		return otto.UndefinedValue()
	}); err != nil {
		panic(err)
	}

	must(l.EvalAndRun(`Promise.all([1,2,3,4,5].map(function(i) { return fetch('/' + i); })).then(__capture)`))

	<-ch
}
Ejemplo n.º 23
0
// Start running the JavaScript engine.
func (w *JavaScript) Run() {
	if cmd, ok := <-w.Cmd; ok {
		// initial setup
		engine := otto.New()

		// define a callback for sending messages to Out
		engine.Set("emitOut", func(call otto.FunctionCall) otto.Value {
			out, err := call.Argument(0).Export()
			flow.Check(err)
			w.Out.Send(out)
			return otto.UndefinedValue()
		})

		// process the command input
		if _, err := engine.Run(cmd.(string)); err != nil {
			glog.Fatal(err)
		}

		// only start the processing loop if the "onIn" handler exists
		value, err := engine.Get("onIn")
		if err == nil && value.IsFunction() {
			for in := range w.In {
				engine.Call("onIn", nil, in)
			}
		}
	}
}
Ejemplo n.º 24
0
func NewChannelMapper(funcSource string) (*ChannelMapper, error) {
	mapper := &ChannelMapper{}
	mapper.js = otto.New()

	// Implementation of the 'sync()' callback:
	mapper.js.Set("sync", func(call otto.FunctionCall) otto.Value {
		for _, arg := range call.ArgumentList {
			if arg.IsString() {
				mapper.channels = append(mapper.channels, arg.String())
			} else if arg.Class() == "Array" {
				array := ottoArrayToStrings(arg.Object())
				if array != nil {
					mapper.channels = append(mapper.channels, array...)
				}
			}
		}
		return otto.UndefinedValue()
	})

	if _, err := mapper.setFunction(funcSource); err != nil {
		return nil, err
	}

	mapper.requests = make(chan channelMapperRequest)
	go mapper.serve()

	return mapper, nil
}
Ejemplo n.º 25
0
Archivo: otto.go Proyecto: hattya/aster
func os_remove(call otto.FunctionCall) otto.Value {
	if 1 <= len(call.ArgumentList) {
		path, _ := call.ArgumentList[0].ToString()
		os.RemoveAll(path)
	}
	return otto.UndefinedValue()
}
Ejemplo n.º 26
0
func (js *jsre) pendingTransactions(call otto.FunctionCall) otto.Value {
	txs := js.ethereum.TxPool().GetTransactions()

	// grab the accounts from the account manager. This will help with determening which
	// transactions should be returned.
	accounts, err := js.ethereum.AccountManager().Accounts()
	if err != nil {
		fmt.Println(err)
		return otto.UndefinedValue()
	}

	// Add the accouns to a new set
	accountSet := set.New()
	for _, account := range accounts {
		accountSet.Add(common.BytesToAddress(account.Address))
	}

	//ltxs := make([]*tx, len(txs))
	var ltxs []*tx
	for _, tx := range txs {
		// no need to check err
		if from, _ := tx.From(); accountSet.Has(from) {
			ltxs = append(ltxs, newTx(tx))
		}
	}

	return js.re.ToVal(ltxs)
}
Ejemplo n.º 27
0
func registerVM(vm *modules.JsVm) otto.Value {
	obj, _ := vm.Object("({})")

	obj.Set("do", func(c otto.FunctionCall) otto.Value {
		arg1 := c.Argument(0)
		req := JsoToRequest(arg1.Object())
		followRedirObj, err := arg1.Object().Get("followRedirects")
		followRedirects := true
		if followRedirObj != otto.UndefinedValue() {
			followRedirects, _ = followRedirObj.ToBoolean()
		}

		client := &http.Client{}

		var resp *http.Response
		if followRedirects {
			resp, err = client.Do(req)
		} else {
			resp, err = http.DefaultTransport.RoundTrip(req)
		}

		respObj, _ := vm.Object("({})")
		if err == nil {
			ResponseToJso(respObj, resp)
		}

		return modules.ToResult(vm, respObj, err)
	})
	return obj.Value()
}
Ejemplo n.º 28
0
// Compiles a JavaScript map function to a JSMapFunction object.
func NewJSMapFunction(funcSource string) (*JSMapFunction, error) {
	mapper := &JSMapFunction{}
	var err error
	mapper.js, err = NewJSServer(funcSource)
	if err != nil {
		return nil, err
	}

	// Implementation of the 'emit()' callback:
	mapper.js.DefineNativeFunction("emit", func(call otto.FunctionCall) otto.Value {
		key, err1 := ottoToGo(call.ArgumentList[0])
		value, err2 := ottoToGo(call.ArgumentList[1])
		if err1 != nil || err2 != nil {
			panic(fmt.Sprintf("Unsupported key or value types: key=%v, value=%v", key, value))
		}
		mapper.output = append(mapper.output, ViewRow{Key: key, Value: value})
		return otto.UndefinedValue()
	})

	mapper.js.Before = func() {
		mapper.output = []ViewRow{}
	}
	mapper.js.After = func(result otto.Value, err error) (interface{}, error) {
		output := mapper.output
		mapper.output = nil
		return output, err
	}
	return mapper, nil
}
Ejemplo n.º 29
0
func prettyPrintJS(call otto.FunctionCall) otto.Value {
	for _, v := range call.ArgumentList {
		prettyPrint(call.Otto, v)
		fmt.Println()
	}
	return otto.UndefinedValue()
}
Ejemplo n.º 30
0
func (js *jsre) newAccount(call otto.FunctionCall) otto.Value {
	arg := call.Argument(0)
	var passphrase string
	if arg.IsUndefined() {
		fmt.Println("The new account will be encrypted with a passphrase.")
		fmt.Println("Please enter a passphrase now.")
		auth, err := readPassword("Passphrase: ", true)
		if err != nil {
			utils.Fatalf("%v", err)
		}
		confirm, err := readPassword("Repeat Passphrase: ", false)
		if err != nil {
			utils.Fatalf("%v", err)
		}
		if auth != confirm {
			utils.Fatalf("Passphrases did not match.")
		}
		passphrase = auth
	} else {
		var err error
		passphrase, err = arg.ToString()
		if err != nil {
			fmt.Println(err)
			return otto.FalseValue()
		}
	}
	acct, err := js.ethereum.AccountManager().NewAccount(passphrase)
	if err != nil {
		fmt.Printf("Could not create the account: %v", err)
		return otto.UndefinedValue()
	}
	return js.re.ToVal("0x" + common.Bytes2Hex(acct.Address))
}