providerindex

Documentation

Index

• func Cache(ctx context.Context, providerStore types.ProviderStore, provider peer.AddrInfo, ...) error
• type ContentToClaimsMapper
• type LegacyClaimsFinder
• type LegacyClaimsStore
  • func NewLegacyClaimsStore(contentToClaimsMapper ContentToClaimsMapper, ...) (LegacyClaimsStore, error)
  • func (ls LegacyClaimsStore) Find(ctx context.Context, contentHash multihash.Multihash) ([]model.ProviderResult, error)
• type NoResultsLegacyClaimsFinder
  • func NewNoResultsLegacyClaimsFinder() NoResultsLegacyClaimsFinder
  • func (f NoResultsLegacyClaimsFinder) Find(ctx context.Context, contentHash multihash.Multihash) ([]model.ProviderResult, error)
• type ProviderIndex
• type ProviderIndexService
  • func New(providerStore types.ProviderStore, findClient ipnifind.Finder, ...) *ProviderIndexService
  • func (pi *ProviderIndexService) Cache(ctx context.Context, provider peer.AddrInfo, contextID string, ...) error
  • func (pi *ProviderIndexService) Find(ctx context.Context, qk QueryKey) ([]model.ProviderResult, error)
  • func (pi *ProviderIndexService) Publish(ctx context.Context, provider peer.AddrInfo, contextID string, ...) error
• type QueryKey
• type RemoteSyncer
  • func NewRemoteSyncer(providerStore types.ProviderStore, store Store) *RemoteSyncer
  • func (rs *RemoteSyncer) HandleRemoteSync(ctx context.Context, head, prev ipld.Link)
• type Store

Functions

func Cache

func Cache(ctx context.Context, providerStore types.ProviderStore, provider peer.AddrInfo, contextID string, digests iter.Seq[mh.Multihash], meta meta.Metadata, expire bool) error

Types

type ContentToClaimsMapper

type ContentToClaimsMapper interface {
	GetClaims(ctx context.Context, contentHash multihash.Multihash) (claimsCids []cid.Cid, err error)
}

ContentToClaimsMapper maps content hashes to claim cids

type LegacyClaimsFinder

type LegacyClaimsFinder interface {
	// Find returns a list of claims for a given content hash.
	// Implementations should return an empty slice and no error if no results are found.
	Find(ctx context.Context, contentHash multihash.Multihash) ([]model.ProviderResult, error)
}

LegacyClaimsFinder is a read-only interface to find claims on a legacy system

type LegacyClaimsStore

type LegacyClaimsStore struct {
	// contains filtered or unexported fields
}

LegacyClaimsStore allows finding claims on a legacy store

func NewLegacyClaimsStore

func NewLegacyClaimsStore(contentToClaimsMapper ContentToClaimsMapper, claimStore types.ContentClaimsStore, claimsUrl string) (LegacyClaimsStore, error)

func (LegacyClaimsStore) Find

func (ls LegacyClaimsStore) Find(ctx context.Context, contentHash multihash.Multihash) ([]model.ProviderResult, error)

Find looks for the corresponding claims for a given content hash in the mapper and then fetches the claims from the claims store

type NoResultsLegacyClaimsFinder

type NoResultsLegacyClaimsFinder struct{}

NoResultsLegacyClaimsFinder is a LegacyClaimsFinder that returns no results. It can be used when accessing claims in a legacy system is not required

func NewNoResultsLegacyClaimsFinder

func NewNoResultsLegacyClaimsFinder() NoResultsLegacyClaimsFinder

func (NoResultsLegacyClaimsFinder) Find

func (f NoResultsLegacyClaimsFinder) Find(ctx context.Context, contentHash multihash.Multihash) ([]model.ProviderResult, error)

Find always returns no results

type ProviderIndex

type ProviderIndex interface {
	// Find should do the following
	//  1. Read from the IPNI Storage cache to get a list of providers
	//     a. If there is no record in cache, query IPNI, filter out any non-content claims metadata, and store
	//     the resulting records in the cache
	//     b. the are no records in the cache or IPNI, it can attempt to read from legacy systems -- Dynamo tables & content claims storage, synthetically constructing provider results
	//  2. With returned provider results, filter additionally for claim type. If space dids are set, calculate an encodedcontextid's by hashing space DID and Hash, and filter for a matching context id
	//     Future TODO: kick off a conversion task to update the recrds
	Find(context.Context, QueryKey) ([]model.ProviderResult, error)
	// Cache writes entries to the cache but does not publish/announce an
	// advertisement for them. Entries expire after a pre-determined time.
	Cache(ctx context.Context, provider peer.AddrInfo, contextID string, digests iter.Seq[multihash.Multihash], meta meta.Metadata) error
	// Publish should do the following:
	// 1. Write the entries to the cache with no expiration until publishing is complete
	// 2. Generate an advertisement for the advertised hashes and publish/announce it
	Publish(ctx context.Context, provider peer.AddrInfo, contextID string, digests iter.Seq[multihash.Multihash], meta meta.Metadata) error
}

ProviderIndex is a read/write interface to a local cache of providers that falls back to legacy systems and IPNI

type ProviderIndexService

type ProviderIndexService struct {
	// contains filtered or unexported fields
}

ProviderIndexService is a read/write interface to a local cache of providers that falls back to IPNI

func New

func New(providerStore types.ProviderStore, findClient ipnifind.Finder, publisher publisher.Publisher, legacyClaims LegacyClaimsFinder) *ProviderIndexService

func (*ProviderIndexService) Cache

func (pi *ProviderIndexService) Cache(ctx context.Context, provider peer.AddrInfo, contextID string, digests iter.Seq[mh.Multihash], meta meta.Metadata) error

func (*ProviderIndexService) Find

func (pi *ProviderIndexService) Find(ctx context.Context, qk QueryKey) ([]model.ProviderResult, error)

Find should do the following

1. Read from the IPNI Storage cache to get a list of providers a. if there are no records in the cache, query IPNI, filtering out any non-content claims metadata b. if no records are found in IPNI, attempt to read claims from legacy systems -- Dynamo tables & content claims storage, synthetically constructing provider results c. finally, store the resulting records in the cache
2. With returned provider results, filter additionally for claim type. If space dids are set, calculate an encodedcontextid's by hashing space DID and Hash, and filter for a matching context id Future TODO: kick off a conversion task to update the records

func (*ProviderIndexService) Publish

func (pi *ProviderIndexService) Publish(ctx context.Context, provider peer.AddrInfo, contextID string, digests iter.Seq[mh.Multihash], meta meta.Metadata) error

Publish should do the following: 1. Write the entries to the cache with no expiration until publishing is complete 2. Generate an advertisement for the advertised hashes and publish/announce it

type QueryKey

type QueryKey struct {
	Spaces       []did.DID
	Hash         mh.Multihash
	TargetClaims []multicodec.Code
}

type RemoteSyncer

type RemoteSyncer struct {
	// contains filtered or unexported fields
}

func NewRemoteSyncer

func NewRemoteSyncer(providerStore types.ProviderStore, store Store) *RemoteSyncer

func (*RemoteSyncer) HandleRemoteSync

func (rs *RemoteSyncer) HandleRemoteSync(ctx context.Context, head, prev ipld.Link)

type Store

type Store interface {
	store.EntriesReadable
	store.AdvertReadable
}