nsmcp::accessScanProgress

 nsmcp::accessScanProgress

Defined in

Partial Call Graph (max 5 caller/called nodes):

Testcases:

No testcase defined.

Source code:

    set done 0
    set skipped 0
    set scanned 0
    set pending 0
    foreach entry [dict get $state files] {
        if {[dict get $entry status] eq "complete"} {
            incr done
        }
        if {[dict get $entry status] eq "outside-window"} {
            incr skipped
        }
        if {[dict exists $entry scanStarted]} {
            incr scanned
        }
        if {[dict get $entry status] ni {complete outside-window}} {
            incr pending
        }
    }
    set fields [list phase string $phase updatedAt number [clock seconds]  examinedBytes number [dict get $state examinedBytes] filesCompleted number $done  filesProcessed number [dict get $state index] filesSelected number [llength [dict get $state files]]  filesDiscovered number [llength [dict get $state files]] filesSkipped number $skipped filesScanned number $scanned filesPending number $pending]
    if {[dict exists $state aggregate backend]} {
        lappend fields aggregationBackend string [dict get $state aggregate backend]
        foreach key {poolWaitCount poolWaitMilliseconds poolWaitLimitMilliseconds} {
            if {[dict exists $state aggregate $key]} {
                lappend fields aggregation[string toupper [string index $key 0]][string range $key 1 end] number [dict get $state aggregate $key]
            }
        }
        if {[dict exists $state aggregate failure] && [dict get $state aggregate failure] ne {}} {
            foreach {key field} {phase aggregationFailurePhase class aggregationFailureClass diagnosticId aggregationDiagnosticId} {
                lappend fields $field string [dict get $state aggregate failure $key]
            }
        }
        if {[dict get $state aggregate backend] eq "sqlite"} {
            lappend fields aggregationDiskBytes number [dict get $state aggregate diskBytes] aggregationDiskBudgetBytes number [dict get $state aggregate maxBytes]  aggregationStatus string [dict get $state aggregate status]
        }
    }
    if {[dict exists $state selectionProbeBytes]} {
        lappend fields selectionProbeBytes number [dict get $state selectionProbeBytes]
    }
    if {[dict exists $state limits bytes]} {
        lappend fields scanBudgetBytes number [dict get $state limits bytes]
    }
    foreach key {scanStatus completionSummary} {
        if {[dict exists $completion $key]} {
            lappend fields $key string [dict get $completion $key]
        }
    }
    if {[dict exists $completion truncatedByLimits]} {
        lappend fields truncatedByLimits boolean [dict get $completion truncatedByLimits]
    }
    if {$file eq ""} {
        foreach key {currentFileIndex currentFileNumber currentFileSize currentFileOffset currentFileSnapshotBytes} {
            lappend fields $key null {}
        }
        lappend fields offsetBasis string {} currentFileCompressed boolean false
    } else {
        if {$offset eq ""} {
            set offset [dict get $file offset]
        }
        if {[dict exists $file orderedSelection]} {
            set size [expr {[dict exists $file decodedSize] ? [dict get $file decodedSize] : [dict get $file size]}]
            lappend fields selectedFromOffset number [dict get $file scanStart] selectedToOffset number [dict get $file scanEnd]
        }
        if {$size eq "" && $phase ne "decompressing"} {
            if {![dict get $file compressed]} {
                set size [dict get $file size]
            }
            if {[dict exists $file decodedSize]} {
                set size [dict get $file decodedSize]
            }
        }
        lappend fields currentFileIndex number [dict get $file fileIndex]  currentFileNumber number [expr {[dict get $file fileIndex]+1}]  currentFileSize [expr {$size eq "" ? "null" : "number"}] $size  currentFileOffset number $offset currentFileSnapshotBytes number [dict get $file size]  currentFileCompressed boolean [dict get $file compressed]  offsetBasis string [expr {[dict get $file compressed] ? "decompressed" : "file"}]
    }
    if {$file ne ""} {
        foreach key {timeIndexSkippedBytes timeIndexValidationBytes} {
            if {[dict exists $file $key]} {
                lappend fields $key number [dict get $file $key]
            }
        }
    }
    if {$publish ne ""} {
        uplevel #0 [list {*}$publish $fields]
    }
    return $fields

XQL Not present:

Generic, PostgreSQL, Oracle