nsmcp::AccessScan object method progress (public)

 nsmcp::AccessScan[i] progress publish phase state file [ offset ] \
    [ size ] [ completion ]

Defined in /usr/local/ns/tcl/nsmcp/log-traffic-summary.tcl

Publish bounded progress for the selected scan phase and source. Omit paths and addresses. Gzip size is unknown until decoding.

Parameters:
publish (required)
phase (required)
state (required)
file (required)
offset (optional)
size (optional)
completion (optional)

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
[ hide source ] | [ make this the default ]
Show another procedure: