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
}