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.")) } if request.State() == FATAL { request.Failed(this) return } maxParallelism := request.MaxParallelism() if maxParallelism <= 0 { maxParallelism = this.MaxParallelism() } context := execution.NewContext(request.Id().String(), this.datastore, this.systemstore, namespace, this.readonly, maxParallelism, request.NamedArgs(), request.PositionalArgs(), request.Credentials(), request.ScanConsistency(), request.ScanVectorSource(), request.Output()) build := time.Now() operator, er := execution.Build(prepared, context) if er != nil { error, ok := er.(errors.Error) if ok { request.Fail(error) } else { request.Fail(errors.NewError(er, "")) } } if logging.LogLevel() >= logging.TRACE { request.Output().AddPhaseTime("instantiate", time.Since(build)) } if request.State() == FATAL { 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()) run := time.Now() operator.RunOnce(context, nil) if logging.LogLevel() >= logging.TRACE { request.Output().AddPhaseTime("run", time.Since(run)) logPhases(request) } }