func getReadonly(a httpRequestArgs, isGet bool) (value.Tristate, errors.Error) {
readonly, err := a.getTristate(READONLY)
if err == nil && isGet {
switch readonly {
case value.NONE:
readonly = value.TRUE
case value.FALSE:
err = errors.NewServiceErrorReadonly(
fmt.Sprintf("%s=false cannot be used with HTTP GET method.", READONLY))
}
}
return readonly, 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)
}
}