nsmcp::QuestionService method run (public)

 <instance of nsmcp::QuestionService> run handle turn

Defined in /usr/local/ns/tcl/nsmcp/question-service.tcl

Parameters:

handle (required)

turn (required)

Testcases:

No testcase defined.

Source code:

ns_mutex lock ${:mutex}
try {
    if {![nsv_exists ${:store} $handle]} {return}
    set record [nsv_get ${:store} $handle]
    if {[dict get $record current] ne $turn} {return}
    if {[dict get $record status] in {cancelling cancelled}} {
        set skip true
    } else {
        set skip false
        dict set record status running
        nsv_set ${:store} $handle $record
    }
    set state [dict get $record state]
    if {[dict exists $record stateEncoding]} {
        set state [encoding convertfrom utf-8 [zlib decompress $state]]
    }
    set backendName [:defaultBackend]
    if {[dict exists $record backend]} {set backendName [dict get $record backend]}
    set question [dict get [lindex [dict get $record turns] end] question]
} finally {ns_mutex unlock ${:mutex}}
# A timed-out turn may have started a job without publishing provider
# history. Carry its handle explicitly into the next question.
set pendingJobs {}
foreach previous [dict get $record turns] {
    if {![dict exists $previous jobs]} continue
    dict for {jobHandle job} [dict get $previous jobs] {
        dict set job needsRetrieval [expr {[dict get $previous status] in {failed cancelled}
            || [dict get $job status] in {queued running}}]
        dict set pendingJobs $jobHandle $job
    }
}
dict for {jobHandle job} $pendingJobs {
    if {[dict get $job needsRetrieval]} {
        append question "\nExisting background jobHandle $jobHandle ([dict get $job name]); retrieve it with log_results rather than starting it again."
    }
}
set error {}
set status cancelled
if {!$skip} {
    if {[catch {[:provider $backendName] run $question $state [list [self] event $handle $turn]} status]} {
        set error $status
        set status failed
    }
}
ns_mutex lock ${:mutex}
try {
    if {![nsv_exists ${:store} $handle]} {return}
    set record [nsv_get ${:store} $handle]
    if {[dict get $record current] ne $turn} {return}
    if {[dict get $record status] eq "cancelling"} {set status cancelled; set error {}}
    dict set record status $status
    set last [lindex [dict get $record turns] end]
    dict set last status $status
    dict set last error $error
    dict set record turns [lreplace [dict get $record turns] end end $last]
    nsv_set ${:store} $handle $record
} finally {ns_mutex unlock ${:mutex}}

XQL Not present:

Generic, PostgreSQL, Oracle