Where the “haves” are computed

There are two levels.

File:

backend/hmnet/syncing/discovery.go

In:

DiscoverObjectWithProgress(...)

The code builds one local RBSR store:

store := newAuthorizedStore()
err := s.db.WithSave(ctx, func(conn *sqlite.Conn) error {
    return loadRBSRStore(conn, dkeys, store)
})
store.Seal()

The DB-heavy part is:

loadRBSRStore(...)

which calls:

collectBlobs(...)
fillTables(...)

and then inserts CIDs into the in-memory RBSR store.

File:

backend/hmnet/syncing/syncing.go

In:

syncWithPeer(...)

Each peer gets authorization-specific filtering:

authorizedSpaces, err := s.index.GetAuthorizedSpacesForPeer(ctx, pid, requestedIRIs)
filteredStore := store.WithFilter(authorizedSpaces)

Then:

syncResources(..., filteredStore, ...)

Inside syncResources, haves/wants are computed by RBSR:

msg, err = ne.ReconcileWithIDs(msg, &haves, &wants)

Actual haves append is in:

backend/hmnet/syncing/rbsr/rbsr.go

*haveIDs = append(*haveIDs, have)

Why private docs make grouping harder

Before private docs, all peers could see the same local store:

same haves for everyone

After private docs, each peer may be authorized for different private spaces:

peer A can see public + private space X
peer B can see public only
peer C can see public + private space Y

So the daemon cannot blindly reuse the exact same “haves” list for every peer.

That is why the code has:

store.WithFilter(authorizedSpaces)

Even with private docs, we can group peers by authorization set.

Example:

peer A authorized spaces: [space1, space2]
peer B authorized spaces: [space1, space2]
peer C authorized spaces: []
peer D authorized spaces: []

Then A and B can share one filtered store/session, and C and D can share another.

Potential optimization:

build base store once
compute authorizedSpaces per peer
group peers by authorizedSpaces key
create filteredStore once per group
reuse within group

Also, public-only peers probably all share the same filtered store.

The haves are computed in syncing.go via RBSR reconciliation, using a store built in discovery.go.

DB-heavy store build: discovery.go → loadRBSRStore.
Per-peer private filtering: syncing.go → store.WithFilter(authorizedSpaces).
Actual haves append: rbsr.go → ReconcileWithIDs.
Private docs make global grouping harder, but grouping by identical authorization sets is still possible.