github::ActivityMonitor method sync_work (protected)

 <instance of github::ActivityMonitor[i]> sync_work

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

Testcases:
No testcase defined.
Source code:
ns_log Notice "GitHub: refresh_activity start"
set jobs [:get_state pending_backfills {}]
set heads [:get_state reconciled_branch_heads {}]

# Convert old unbounded jobs once. Page numbers of the recent
# filtered list differ, so restart jobs without a baseline.
set removed 0
dict for {key job} $jobs {
    lassign $key repo branch
    if {![:branch_enabled $branch]} {
        dict unset jobs $key
        incr removed
        continue
    }
    if {![dict exists $job since]} {
        dict set jobs $key since [:recent_since]
        if {![dict exists $job base] || [dict get $job base] eq ""} {
            dict set jobs $key next_page 1
        }
    }
}
:set_state pending_backfills $jobs
if {$removed > 0} {
    ns_log Notice "GitHub: removed $removed excluded branch job(s) from pending queue"
}
if {[catch {:discover jobs $heads} message options]} {
    :set_state discovery_error $message
    ns_log Warning "GitHub: discovery deferred: $message"
} else {
    :set_state discovery_error ""
}

set new_events {}
if {[catch {set new_events [:fetch_new_events]} errorMsg]} {
    ns_log Error "GitHub: fetching events failed: $errorMsg"
}
foreach ev $new_events {
    if {[dict get $ev type] ne "PushEvent"} {
        continue
    }
    set ref [dict get $ev payload ref]
    if {![string match "refs/heads/*" $ref]} {
        continue
    }
    set repo [dict get $ev repo name]
    set branch [string range $ref [string length "refs/heads/"] end]
    set revision [dict get $ev payload head]
    # Deleted branches have a zero head, with no history to fetch.
    if {$revision eq "" || [regexp {^0+$} $revision]} {
        continue
    }
    set observed [:get_state observed_branch_heads {}]
    set key [list $repo $branch]
    if {[dict exists $observed $key]} {set revision [dict get $observed $key]}
    :queue_backfill jobs $repo $branch $revision
}

# Checkpointing events is safe only after their work is durable.
:set_state pending_backfills $jobs
if {[llength $new_events] > 0} {
    :set_state last_org_event_id [dict get [lindex $new_events end] id]
}

dict for {key job} $jobs {
    if {${:requests_left} <= 0 || [clock seconds] >= ${:deadline}} {break}
    lassign $key repo branch
    set revision [dict get $job revision]
    # Missing baselines use the job's fixed recent-history window.
    set base ""
    if {[dict exists $job base]} {set base [dict get $job base]}
    if {[catch {
        set progress [:backfill_locked  -repo $repo -branch $branch  -revision $revision -base $base -since [dict get $job since]  -start_page [dict get $job next_page]  -max_pages ${:backfill_pages_per_run}]
    } errorMsg options]} {
        # Rotate unfinished/failed jobs so one large branch cannot
        # monopolize the first requests on every invocation.
        dict unset jobs $key
        dict set jobs $key $job
        :set_state pending_backfills $jobs
        if {[dict get $options -errorcode] in {
            {GITHUB BUDGET} {GITHUB RATE_LIMIT} {GITHUB HTTP 403} {GITHUB HTTP 429}
        }} {break}
        set errors [:get_state backfill_errors {}]
        dict set errors $key $errorMsg
        :set_state backfill_errors $errors
        ns_log Error "GitHub: backfill failed for $repo $branch; retained for retry: $errorMsg"
        continue
    }
    set errors [:get_state backfill_errors {}]
    if {[dict exists $errors $key]} {dict unset errors $key; :set_state backfill_errors $errors}
    if {[dict get $progress complete]} {
        set attention [:get_state attention_required {}]
        if {[dict exists $attention $key]} {dict unset attention $key; :set_state attention_required $attention}
        dict set heads $key $revision
        # Save the successful head before removing its retry job.
        :set_state reconciled_branch_heads $heads
        dict unset jobs $key
        if {[dict exists $job followup_revision]} {
            :queue_backfill jobs $repo $branch [dict get $job followup_revision]
        }
    } else {
        dict unset jobs $key
        dict set job next_page [dict get $progress next_page]
        dict set job base [dict get $progress base]
        dict set jobs $key $job
    }
    :set_state pending_backfills $jobs
}
set summary [dict create finished_at [clock seconds] pending_branches [dict size $jobs]  pending_repository_checks [dict size [:get_state recent_repository_checks {}]]  requests_used [expr {${:max_requests_per_run} - ${:requests_left}}]]
:set_state last_sync_status $summary
ns_log Notice "GitHub: refresh_activity done; $summary"
XQL Not present:
Generic, PostgreSQL, Oracle
[ hide source ] | [ make this the default ]
Show another procedure: