func (this *Context) Recover() {
err := recover()
if err != nil {
buf := make([]byte, 1<<16)
n := runtime.Stack(buf, false)
s := string(buf[0:n])
logging.Severep("", logging.Pair{"panic", err},
logging.Pair{"stack", s})
os.Stderr.WriteString(s)
os.Stderr.Sync()
switch err := err.(type) {
case error:
this.Fatal(errors.NewError(err, fmt.Sprintf("Panic: %v", err)))
default:
this.Fatal(errors.NewError(nil, fmt.Sprintf("Panic: %v", err)))
}
}
}
func (this *Server) serviceRequest(request Request) {
defer func() {
err := recover()
if err != nil {
buf := make([]byte, 1<<16)
n := runtime.Stack(buf, false)
s := string(buf[0:n])
logging.Severep("", logging.Pair{"panic", err},
logging.Pair{"stack", s})
os.Stderr.WriteString(s)
os.Stderr.Sync()
}
}()
request.Servicing()
namespace := request.Namespace()
if namespace == "" {
namespace = this.namespace
}
prepared, err := this.getPrepared(request, namespace)
if err != nil {
request.Fail(err)
}
if (this.readonly || value.ToBool(request.Readonly())) &&
(prepared != nil && !prepared.Readonly()) {
request.Fail(errors.NewServiceErrorReadonly("The server or request is read-only" +
" and cannot accept this write statement."))
}
var operator execution.Operator
if request.State() != FATAL {
var err error
operator, err = execution.Build(prepared)
if err != nil {
request.Fail(errors.NewError(err, ""))
}
}
if request.State() == FATAL {
// Fail the request - Write out response - and return
request.Failed(this)
return
}
// Apply server execution timeout
if this.timeout > 0 {
timer := time.AfterFunc(this.timeout, func() { request.Expire() })
defer timer.Stop()
}
go request.Execute(this, prepared.Signature(), operator.StopChannel())
context := execution.NewContext(this.datastore, this.systemstore, namespace,
this.readonly, request.NamedArgs(), request.PositionalArgs(), request.Credentials(),
request.ScanConsistency(), request.ScanVector(),
request.Output())
operator.RunOnce(context, nil)
}