Files
archie/internal/app/archied/issue_discovery.go
T
sam cc5789eb5f feat(scheduling): schedules and runs in the State Store with grid timing and run history
Schedules leave the schedules control-plane resource for State Store tables
behind a ScheduleService contract. A run is claimed per schedule slot, missed
slots fire once, the next run stays on the schedule's grid, cron is read in the
schedule-settings time zone, and failed runs are recorded and advance. Three
failures in a row raise a schedule.failing alert. A fired run records a
schedule-fired capture. Run history is pruned by age and count.

Removes the chat and spawn-task runners, the dangerous-payload guard and the
old schedules settings page.
2026-10-26 00:49:24 +11:00

162 lines
5.6 KiB
Go

package archied
import (
"context"
"encoding/json"
"github.com/samcharles93/archie-core/internal/app/servicekit"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/daemon"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanestore"
)
// orgAgents is every organisation with the principals that may act in it,
// system org first. The system org's own root identity leads its list.
type orgAgents struct {
owner org.OrgID
principals []access.Principal
}
// act returns ctx acting in the organisation. The system org is the
// daemon's own, so it needs no agent principal.
func (o orgAgents) act(ctx context.Context) context.Context {
if o.owner == org.DefaultOrgID {
return ctx
}
return org.WithOrg(access.WithPrincipal(ctx, o.principals[0]), o.owner)
}
// orgDirectory finds every organisation and an agent principal to act as in
// each, because the control plane serves a caller only its own org.
type orgDirectory interface {
access.PrincipalSource
ListOrgs(ctx context.Context) ([]org.Org, error)
ListOrgAgents(ctx context.Context, id org.OrgID) ([]org.AgentAssignment, error)
}
// owners lists every org, system org first. Without the directory the system
// org still runs.
func (b *boot) owners(ctx context.Context, directory orgDirectory) []org.OrgID {
owners := []org.OrgID{org.DefaultOrgID}
if directory == nil {
return owners
}
list, err := directory.ListOrgs(ctx)
if err != nil {
b.log.WarnContext(ctx, "organisations unavailable; acting in the system organisation only", "err", err)
return owners
}
for _, o := range list {
if o.ID != org.DefaultOrgID {
owners = append(owners, o.ID)
}
}
return owners
}
func (b *boot) organisations(ctx context.Context) []orgAgents {
directory, _ := b.stateStore.(orgDirectory)
var out []orgAgents
for _, owner := range b.owners(ctx, directory) {
entry := orgAgents{owner: owner}
if owner == org.DefaultOrgID && directory != nil {
root := identity.StableID(servicekit.IdentityNames(b.cfgHolder.Get())[0])
if principal, err := directory.PrincipalFor(ctx, root); err == nil {
entry.principals = append(entry.principals, principal)
}
}
if directory != nil {
agents, err := directory.ListOrgAgents(ctx, owner)
if err != nil {
b.log.WarnContext(ctx, "organisation agents unavailable", "org", owner, "err", err)
}
for _, agent := range agents {
principal, err := directory.PrincipalFor(ctx, agent.IdentityID)
if err == nil && principal.Org == owner {
entry.principals = append(entry.principals, principal)
}
}
}
if owner != org.DefaultOrgID && len(entry.principals) == 0 {
b.log.WarnContext(ctx, "organisation skipped: no agent to act as", "org", owner)
continue
}
out = append(out, entry)
}
return out
}
// orgPrincipals is the first acting principal of every organisation.
func (b *boot) orgPrincipals(ctx context.Context) []access.Principal {
var out []access.Principal
for _, o := range b.organisations(ctx) {
if len(o.principals) > 0 {
out = append(out, o.principals[0])
}
}
return out
}
// issueSources resolves every organisation's repository bindings to their
// connections, each read through the first agent its permits allow to clone.
// It runs every poll cycle, so a rotated credential applies to the next poll.
func (b *boot) issueSources(ctx context.Context) []daemon.IssueSource {
var out []daemon.IssueSource
for _, o := range b.organisations(ctx) {
log := b.log.With("org", o.owner)
octx := o.act(ctx)
var repos []config.Repo
if _, found, err := b.controlPlane.Query(octx, controlplanestore.RepositoryPoliciesKind, func(value []byte) error { return json.Unmarshal(value, &repos) }); err != nil || !found {
log.WarnContext(ctx, "issue discovery: repositories unavailable", "err", err)
continue
}
connections, err := b.repositoryConnections(octx)
if err != nil {
log.WarnContext(ctx, "issue discovery: connections unavailable", "err", err)
continue
}
byConnection := map[string][]config.Repo{}
for _, repo := range repos {
if repo.Connection == "" {
log.WarnContext(ctx, "issue discovery: repository has no connection", "repo", repo.FullName())
continue
}
byConnection[repo.Connection] = append(byConnection[repo.Connection], repo)
}
for _, connection := range connections {
bound := byConnection[connection.ID]
if len(bound) == 0 {
continue
}
if source, ok := b.connectionSource(octx, o, connection, bound); ok {
out = append(out, source)
}
}
}
return out
}
func (b *boot) connectionSource(ctx context.Context, o orgAgents, connection config.ForgeConnection, repos []config.Repo) (daemon.IssueSource, bool) {
log := b.log.With("org", o.owner, "connection", connection.ID)
for _, principal := range o.principals {
if !connection.Permitted(string(principal.IdentityID), config.OperationClone) {
continue
}
resolved, err := b.openRepositoryConnection(ctx, principal, repos[0], connection, config.OperationClone)
if err != nil {
log.WarnContext(ctx, "issue discovery: connection unavailable", "err", err)
return daemon.IssueSource{}, false
}
user := resolved.Trees.AuthUser
if user == "" && o.owner == org.DefaultOrgID {
user = b.cfgHolder.Get().BotUser
}
return daemon.IssueSource{Identity: principal.IdentityID, Forge: resolved.Forge, BotUser: user, Repos: repos}, true
}
log.WarnContext(ctx, "issue discovery: no agent may clone through this connection")
return daemon.IssueSource{}, false
}