config

type AdminServer struct {
	// Admin is the admin API listen address
	ListenMultiaddr string
	ReadTimeout     Duration
	WriteTimeout    Duration
}

type Bootstrap struct {
	// Peers is the local nodes's bootstrap peer addresses
	Peers []string
	// MinimumPeers governs whether to bootstrap more connections. If the node
	// has less open connections than this number, it will open connections to
	// the bootstrap nodes.  Set to 0 to disable bootstrapping.
	MinimumPeers int
}

type Config struct {
	Identity         Identity
	Datastore        Datastore
	Ingest           Ingest
	ProviderServer   ProviderServer
	AdminServer      AdminServer
	Bootstrap        Bootstrap
	DirectAnnounce   DirectAnnounce
	DelegatedRouting DelegatedRouting
}

type Datastore struct {
	// Type is the type of datastore
	Type string
	// Dir is the directory within the config root where the datastore is kept
	Dir string
}

type DelegatedRouting struct {
	ListenMultiaddr string
	ReadTimeout     Duration
	WriteTimeout    Duration
	// CidTtl is a lifetime of a cid after which it is considered expired
	CidTtl Duration
	// AdFlushFrequency defines a frequency of a flush operation that is going to be performed on the current chunk. In other words a non empty
	// current chunk will be converted to an advertisement and published if it's older than this value. Set to 0 to disable.
	AdFlushFrequency Duration
	// ChunkSize is size of a chunk before it gets advertised to an indexer.
	// In other words it's a number of CIDs per advertisement
	ChunkSize int
	// SnapshotSize is the maximum number of records in the Provide payload after which it is considered a snapshot.
	// Snapshots don't have individual timestamps recorded into the datastore. Instead, timestamps are recorded as a binary blob after processing is done.
	SnapshotSize int
	// ProviderID is a Peer ID of the IPFS node that the delegated routing server is expecting advertisements from
	ProviderID string
	// DsPageSize is a size of the database page that is going to be used on delegated routing server initialisation.
	DsPageSize int
	// Addrs is a list of multiaddresses of the IPFS node that the delegated routing server is expecting advertisements from
	Addrs []string
}

type DirectAnnounce struct {
	// NoPubsubAnnounce disables pubsub announce when set to true. The default
	// behavior (false) is to enable sending advertisement announcements via
	// gossib pubsub.
	NoPubsubAnnounce bool
	// URLs is a list of indexer URLs to send HTTP announce messages to.
	URLs []string
}

type Duration time.Duration

type HttpPublisher struct {
	// AnnounceMultiaddr is the address supplied in the announce message
	// telling indexers the address to use to retrieve advertisements. This
	// configures the addresses to announce when using a Libp2pPublisher,
	// HttpPublisher, or Libp2pHttpPublisher.
	//
	// If not specified, the ListenMultiaddr is used with HttpPubliser, the
	// libp2p host address is used with Libp2pPublisher and both are used with
	// Libp2pHttpPublisher.
	AnnounceMultiaddr string
	// ListenMultiaddr is the address of the interface to listen for HTTP
	// requests for advertisements. Set this to "" to disable serving plain
	// HTTP if only libp2phttp is wanted.
	ListenMultiaddr string
}

type Identity struct {
	PeerID  string
	PrivKey string `json:",omitempty"`
}

type Ingest struct {
	// LinkCacheSize is the maximum number of links that cash can store before
	// LRU eviction.  If a single linked list has more links than the cache can
	// hold, the cache is resized to be able to hold all links.
	LinkCacheSize int
	// LinkedChunkSize is the number of multihashes in each chunk of in the
	// advertised entries linked list.  If multihashes are 128 bytes, then
	// setting LinkedChunkSize = 16384 will result in blocks of about 2Mb when
	// full.
	LinkedChunkSize int
	// PubSubTopic used to advertise ingestion announcements.
	PubSubTopic string
	// PurgeLinkCache tells whether to purge the link cache on daemon startup.
	PurgeLinkCache bool

	// HttpPublisher configures the dagsync ipnisync publisher.
	HttpPublisher HttpPublisher

	// PublisherKind specifies which dagsync.Publisher implementation to use.
	// When set to "http", the publisher serves plain HTTP. When set to
	// "libp2p" the publisher serves HTTP over libp2p. When set to
	// "libp2phttp", the publisher serves both plain HTTP and HTTP over libp2p.
	//
	// Plain HTTP is disabled if HttpPublisher.ListenMultiaddr is set to "".
	PublisherKind PublisherKind

	// SyncPolicy configures which indexers are allowed to sync advertisements
	// with this provider over a data transfer session.
	SyncPolicy Policy
}

type Policy struct {
	// Allow is either false or true, and determines whether a peer is allowed
	// (true) or is blocked (false), by default.
	Allow bool
	// Except is a list of peer IDs that are exceptions to the Allow policy.
	// If Allow is true, then all peers are allowed except those listed in
	// Except. If Allow is false, then no peers are allowed except those listed
	// in Except. in other words, Allow=true means that Except is a deny-list
	// and Allow=false means that Except is an allow-list.
	Except []string
}

type ProviderServer struct {
	// ListenMultiaddr is the multiaddr string for the node's listen address
	ListenMultiaddr string
	// RetrievalMultiaddrs are the addresses to advertise for data retrieval.
	// Defaults to the provider's libp2p host listen addresses.
	RetrievalMultiaddrs []string
}

type PublisherKind string