github::ActivityMonitor method discover_recent (protected)

 <instance of github::ActivityMonitor[i]> discover_recent jobsVar \
    stop

Defined in packages/xowiki/tcl/github-activity-monitor-procs.tcl

Parameters:
jobsVar (required)
stop (required)

Testcases:
No testcase defined.
Source code:
upvar 1 $jobsVar jobs
set checks [:get_state recent_repository_checks {}]
set seen [:get_state repository_push_fingerprints {}]
set checked [:get_state repository_checked_at {}]
set hot_since [clock format [expr {[clock seconds] - ${:hot_repository_days} * 86400}] -gmt 1 -format {%Y-%m-%dT%H:%M:%SZ}]
set next_page [:get_state repository_metadata_page 1]
set priority {}
set pages 0
set page 1
# Reserve at least half the discovery allowance for branch checks
# and the background sweep, even with very small user budgets.
set limit [expr {min(${:repository_metadata_pages}, max(1, (${:requests_left} - $stop) / 2))}]
set inventory_deadline [expr {[clock seconds] + max(1, ${:max_seconds_per_run} / 4)}]
while {$pages < $limit && [:discovery_available $stop] && [clock seconds] < $inventory_deadline} {
    set batch [::util::json2dict [:get "/orgs/${:organization}/repos"  [list sort pushed direction desc page $page]]]
    incr pages
    foreach repository $batch {
        set repo [dict get $repository full_name]
        set fingerprint {}
        foreach field {id pushed_at default_branch} {
            lappend fingerprint [expr {[dict exists $repository $field] ? [dict get $repository $field] : ""}]
        }
        lappend fingerprint ${:allowed_branches}
        set hot 0
        if {[dict exists $repository pushed_at]} {
            set pushed [dict get $repository pushed_at]
            set hot [expr {[regexp {^[0-9]{4}-[0-9]{2}-[0-9]{2}T} $pushed]
                && [string compare $pushed $hot_since] >= 0
                && (![dict exists $checked $repo]
                    || [clock seconds] - [dict get $checked $repo] >= ${:reconcile_interval})}]
        }
        if {$hot || ![dict exists $seen $repo] || [dict get $seen $repo] ne $fingerprint} {
            if {![dict exists $checks $repo]
                || [dict get $checks $repo fingerprint] ne $fingerprint} {
                dict set checks $repo [dict create fingerprint $fingerprint page 1]
            }
            if {![dict exists $checks $repo attempted_at]} {lappend priority $repo}
        }
    }
    :set_state recent_repository_checks $checks
    # Page 1 is fetched on EVERY run. Later pages resume when an
    # organization outgrows the small per-run inventory allowance.
    if {[llength $batch] < 100} {
        set next_page 1
        :set_state last_repository_inventory [clock seconds]
        :set_state repository_metadata_page $next_page
        break
    }
    if {$page == 1} {set page [expr {max(2, $next_page)}]} else {incr page}
    set next_page $page
    :set_state repository_metadata_page $next_page
}
set order $priority
foreach repo [dict keys $checks] {
    if {$repo ni $order} {lappend order $repo}
}
set count 0
foreach repo $order {
    if {$count >= ${:fast_repository_checks_per_run} || ![:discovery_available $stop]} {break}
    if {![dict exists $checks $repo]} {continue}
    incr count
    set job [dict get $checks $repo]
    dict set job attempted_at [clock seconds]
    if {[catch {
        set branches [::util::json2dict [:get "/repos/$repo/branches" [list page [dict get $job page]]]]
    } message options]} {
        # Keep a failing/deleted/inaccessible repository from
        # blocking every later repository check in this run.
        dict unset checks $repo
        dict set checks $repo $job
        :set_state recent_repository_checks $checks
        set errors [:get_state repository_check_errors {}]
        dict set errors $repo $message
        :set_state repository_check_errors $errors
        ns_log Warning "GitHub: recent repository check deferred for $repo: $message"
        if {[dict get $options -errorcode] in {{GITHUB BUDGET} {GITHUB RATE_LIMIT} {GITHUB HTTP 403} {GITHUB HTTP 429}}} {
            return -options $options $message
        }
        continue
    }
    :observe_branches jobs $repo $branches [expr {[dict get $job page] == 1}] [expr {[llength $branches] < 100}]
    set errors [:get_state repository_check_errors {}]
    if {[dict exists $errors $repo]} {dict unset errors $repo; :set_state repository_check_errors $errors}
    :set_state pending_backfills $jobs
    if {[llength $branches] < 100} {
        dict set seen $repo [dict get $job fingerprint]
        :set_state repository_push_fingerprints $seen
        dict set checked $repo [clock seconds]
        :set_state repository_checked_at $checked
        dict unset checks $repo
    } else {
        dict incr job page
        dict unset checks $repo
        dict set checks $repo $job
    }
    :set_state recent_repository_checks $checks
}
XQL Not present:
Generic, PostgreSQL, Oracle
[ hide source ] | [ make this the default ]
Show another procedure: