func (ctrl *JsController) addDiscoveryService(o *otto.Otto) { o.Set("discover", func(call otto.FunctionCall) otto.Value { if len(call.ArgumentList) == 0 { glog.Errorf("DISCOVER: Missing arguments") return otto.NullValue() } url, _ := call.Argument(0).ToString() upstreams, err := ctrl.DiscoveryService.Get(url) if err != nil { glog.Errorf("Failed to discover upstreams: %v", err) return otto.NullValue() } glog.Infof("Discovered upstreams: %v", upstreams) result, err := o.ToValue(upstreams) if err != nil { glog.Errorf("Failed to convert: %v", err) return otto.NullValue() } return result }) }
func (b Buffers) Sync(o *otto.Otto) error { if v, err := o.ToValue(b); err != nil { return err } else { o.Set("buffers", v) } return nil }
func newError(o *otto.Otto, inError error) otto.Value { obj := errorToJs(inError) jsObj, err := o.ToValue(obj) if err != nil { glog.Errorf("Error: %s", err) return otto.NullValue() } return jsObj }
func InitEnv(vm *otto.Otto) { vm.Set("G", new(Env)) vm.Set("toJS", func(call otto.FunctionCall) otto.Value { result, err := vm.ToValue(call.Argument(0)) if err != nil { panic(err) } return result }) }
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 }
func funcToOtto(context *otto.Otto, fn reflect.Value) interface{} { return func(call otto.FunctionCall) otto.Value { convertedArgs := make([]reflect.Value, 0) for _, v := range call.ArgumentList { exported, _ := v.Export() convertedArgs = append(convertedArgs, reflect.ValueOf(exported)) } ret := fn.Call(convertedArgs) if len(ret) > 0 { val, _ := context.ToValue(ret[0].Interface()) return val } else { return otto.UndefinedValue() } } }
func makeFilterWithVM(vm *otto.Otto, script string) (func(input string) (string, error), error) { var ( res *http.Response body []byte err error ) res, err = http.Get(REQUIREJS_URL) if err != nil { log.Fatal(err) } body, err = ioutil.ReadAll(res.Body) if err != nil { log.Fatal(err) } res.Body.Close() rjs := string(body[:]) return func(input string) (string, error) { logrus.Debug("Adding RequireJS") vm.Run(rjs) logrus.Debug("Executing script: " + script) _, err := vm.Run(` var module = { "exports": function() { } } `) if err != nil { return "", err } _, err = vm.Run(script) if err != nil { return "", err } event := make(chan otto.Value) oval, err := vm.ToValue(input) if err != nil { return "", err } jscontext := createContext(vm, event) go vm.Call("module.exports", nil, oval, jscontext) value := <-event return value.ToString() }, nil }
func createContext(vm *otto.Otto, event chan otto.Value) otto.Value { var cbfunc = func(invar ...interface{}) { var lovar otto.Value if len(invar) > 0 { lovar, _ = vm.ToValue(invar[0]) } else { lovar = otto.NullValue() } event <- lovar close(event) } vm.Set("_iopipe_cb", cbfunc) vm.Run(`_iopipe_context = { "done": _iopipe_cb, "success": _iopipe_cb, "fail": _iopipe_cb }`) jscontext, _ := vm.Get("_iopipe_context") return jscontext }
func (ctrl *JsController) addGetter(o *otto.Otto) { o.Set("get", func(call otto.FunctionCall) otto.Value { if len(call.ArgumentList) <= 0 { glog.Errorf("GET: Missing arguments") return newError(o, fmt.Errorf("GET: missing arguments")) } // Convert first argument, expect either string with url or list of strings upstreamsI, err := call.Argument(0).Export() if err != nil { glog.Errorf("GET: Failed to export first argument: %s", err) return newError(o, err) } upstreams, err := toStringArray(upstreamsI) if err != nil { glog.Errorf("GET: Failed to convert upstreams: %s", err) return newError(o, err) } // Second argument may be absent var query client.MultiDict if len(call.ArgumentList) > 1 { queryI, err := call.Argument(1).Export() if err != nil { glog.Errorf("GET: Failed to export first argument: %s", err) return newError(o, err) } dict, err := toMultiDict(queryI) if err != nil { glog.Errorf("GET: Failed: %s", err) return newError(o, err) } query = dict } // Third argument is optional username/password object var auth *netutils.BasicAuth if len(call.ArgumentList) > 2 { queryI, err := call.Argument(2).Export() if err != nil { glog.Errorf("GET: Failed: %s", err) return newError(o, err) } creds, err := toBasicAuth(queryI) if err != nil { glog.Errorf("GET: Failed: %s", err) return newError(o, err) } auth = creds } writer := NewResponseWriter() err = ctrl.Client.Get(writer, upstreams, query, auth) if err != nil { glog.Errorf("GET: Failed: %s", err) return newError(o, err) } reply := writer.ToReply() converted, err := o.ToValue(reply) if err != nil { glog.Errorf("GET: Failed: %s", err) return newError(o, err) } return converted }) }
// Returns t as otto.Value or panics func toOttoValueOrPanic(vm *otto.Otto, t interface{}) otto.Value { obj, err := vm.ToValue(t) utils.UnlessNilThenPanic(err) return obj }