func NewMethodInstance(m kit.Method, r kit.Request, responder func(kit.Response)) *methodInstance {
return &methodInstance{
method: m,
request: r,
responder: responder,
blocked: m.IsBlocking(),
stale: false,
}
}
func (f *Frontend) registerMethod(method kit.Method) {
f.client.Register(method.GetName(), func(args []interface{}, kwargs map[string]interface{}, details map[string]interface{}) (result *turnpike.CallResult) {
methodName := method.GetName()
fmt.Printf("WAMP method %v |\n data: %v |\n details: %v\n", methodName, kwargs, details)
request := kit.NewRequest()
request.SetFrontend("wamp")
request.SetPath("/method/" + methodName)
request.SetData(kwargs)
var response kit.Response
// Find session.
sessionId := uint(details["session_id"].(turnpike.ID))
session := f.sessions[sessionId]
if session == nil {
s, err := f.registry.UserService().StartSession(nil, "wamp")
if err != nil {
response = kit.NewErrorResponse(err)
} else {
f.sessions[sessionId] = s
session = s
}
}
request.SetSession(session)
if session.GetUser() != nil {
request.SetUser(session.GetUser())
}
// Run before middlewares.
for _, middleware := range f.beforeMiddlewares {
resp, skip := middleware(f.registry, request)
if skip {
panic("WAMP frontend middlewares do not support skipping.")
} else if resp != nil {
response = resp
break
}
}
// Run the method.
if response == nil {
responder := func(r kit.Response) {
response = r
}
finishedChannel, err := f.registry.App().RunMethod(methodName, request, responder, true)
if err != nil {
response = kit.NewErrorResponse(err)
} else {
<-finishedChannel
}
}
// Run after middlewares.
for _, middleware := range f.afterMiddlewares {
resp, skip := middleware(f.registry, request, response)
if skip {
panic("WAMP frontend middlewares do not support skipping.")
}
if resp != nil {
response = resp
}
}
return &turnpike.CallResult{Kwargs: response.GetData().(map[string]interface{})}
}, nil)
}
func (d *Registry) AddMethod(method kit.Method) {
d.methods[method.GetName()] = method
}