types

Documentation

Index

• Variables
• type Cache
• type ContentClaimsCache
• type ContentClaimsStore
• type ContextID
  • func (c ContextID) ToEncoded() (EncodedContextID, error)
• type EncodedContextID
• type Getter
• type Match
• type ProviderStore
• type Publisher
• type Querier
• type Query
• type QueryResult
• type Service
• type ShardedDagIndexStore
• type Store

Variables

var ErrKeyNotFound = errors.New("key not found")

ErrKeyNotFound means the key did not exist in the cache

var ErrNoRootBlock = errors.New("query root block not found in car")

ErrNoRootBlock indicates a root that is specified but not found in a CAR file

var ErrWrongRootCount = errors.New("query result should have exactly one root")

ErrWrongRootCount indicates a car file with multiple roots being unable to interpret as a query result

Types

type Cache

type Cache[Key, Value any] interface {
	Set(ctx context.Context, key Key, value Value, expires bool) error
	SetExpirable(ctx context.Context, key Key, expires bool) error
	Get(ctx context.Context, key Key) (Value, error)
}

Cache describes a generic cache interface

type ContentClaimsCache

type ContentClaimsCache Cache[cid.Cid, delegation.Delegation]

ContentClaimsCache caches fetched content claims

type ContentClaimsStore

type ContentClaimsStore Store[ipld.Link, delegation.Delegation]

ContentClaimsStore stores published content claims

type ContextID

type ContextID struct {
	Space *did.DID
	Hash  mh.Multihash
}

ContextID describes the data used to calculate a context id for IPNI

func (ContextID) ToEncoded

func (c ContextID) ToEncoded() (EncodedContextID, error)

ToEncoded canonically encodes ContextID data

type EncodedContextID

type EncodedContextID []byte

EncodedContextID is the encoded form of context id data that is actually stored in IPNI

type Getter

type Getter interface {
	// Get retrieves a claim that has been published or cached by the
	// indexing service. No external sources are consulted.
	Get(ctx context.Context, claim ipld.Link) (delegation.Delegation, error)
}

type Match

type Match struct {
	Subject []did.DID
}

Match narrows parameters for locating providers/claims for a set of multihashes

type ProviderStore

type ProviderStore Cache[mh.Multihash, []model.ProviderResult]

ProviderStore caches queries to IPNI

type Publisher

type Publisher interface {
	// Cache caches a claim with the service temporarily.
	Cache(ctx context.Context, provider peer.AddrInfo, claim delegation.Delegation) error
	// Publish writes a claim to permanent storage, adds it to an IPNI
	// advertisement, annnounces it to IPNI nodes and caches it.
	Publish(ctx context.Context, claim delegation.Delegation) error
}

type Querier

type Querier interface {
	// Query allows claims to be queried by their subject (content CID). It
	// returns claims as well as any relevant indexes.
	Query(ctx context.Context, q Query) (QueryResult, error)
}

type Query

type Query struct {
	Hashes []mh.Multihash
	Match  Match
}

Query is a query for several multihashes

type QueryResult

type QueryResult interface {
	ipld.View
	// Claims is a list of links to the root bock of claims that can be found in this message
	Claims() []ipld.Link
	// Indexes is a list of links to the CID hash of archived sharded dag indexes that can be found in this
	// message
	Indexes() []ipld.Link
}

QueryResult is an encodable result of a query

type Service

type Service interface {
	Getter
	Publisher
	Querier
}

Service is the core methods of the indexing service.

type ShardedDagIndexStore

type ShardedDagIndexStore Cache[EncodedContextID, blobindex.ShardedDagIndexView]

ShardedDagIndexStore caches fetched sharded dag indexes

type Store

type Store[Key, Value any] interface {
	// Put adds (or replaces) an item in the store.
	Put(ctx context.Context, key Key, value Value) error
	// Get retrieves an existing item from the store. If the item does not exist,
	// it should return [ErrKeyNotFound].
	Get(ctx context.Context, key Key) (Value, error)
}

Store describes a generic storage interface