bark

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

type BarkConfig struct {
	Logger    *slog.Logger
	DB        *database.Database
	Lifecycle *dblifecycle.Service
	// Node, if set, mounts the LifecycleService (remote Stop, Restart and
	// GetStatus). Like Lifecycle it requires TLS and a client CA. Stop and
	// Restart require LifecycleOperatorCertificateFingerprints.
	Node NodeControl
	// SnapshotDir is the base directory the DatabaseService's CreateSnapshot/
	// Restore RPCs write to and read from — required when Lifecycle is set.
	// Each snapshot's generated ID is its directory name directly under
	// SnapshotDir. DatabaseService maintains a persistent local catalog for
	// bounded ListSnapshots pages and rebuilds it from these directories when
	// the handler starts.
	SnapshotDir string
	// SnapshotCloudDestination, if set, is the same cloud destination URI
	// as databaseLifecycle.snapshotCloudDestination — passed through here
	// so ListAvailableSnapshots can additionally list what's stored there
	// (via database/lifecycle.ListCloudSnapshots), merged with the local
	// catalog. Empty disables cloud listing; CreateSnapshot's own upload
	// path doesn't need this field since it goes through Lifecycle, which
	// already has its own copy of the same config value. The URI may contain
	// provider credentials or parameters and must not be returned directly;
	// SnapshotInfo.location uses a redacted display form.
	SnapshotCloudDestination string
	// DestinationRegistry supplies the cloud destination schemes (s3, gcs)
	// this Bark instance's DatabaseService handler can resolve
	// SnapshotCloudDestination/cloud snapshot URIs against — composition
	// code owns constructing it; nil is valid when no cloud destination
	// is ever configured.
	DestinationRegistry *lifecycle.DestinationRegistry
	TlsCertFilePath     string
	TlsKeyFilePath      string
	// TlsClientCAFilePath is a PEM CA bundle used to verify client
	// certificates (mTLS) on this listener. Required whenever Lifecycle is
	// set: the DatabaseService's destructive RPCs (CreateSnapshot,
	// DeleteSnapshot, VerifySnapshot, Restore, Truncate, CancelOperation)
	// refuse any request whose connection didn't present a certificate
	// verified against this CA — see newOperatorAuthInterceptor in auth.go.
	// ArchiveService remains public, but every DatabaseService RPC requires a
	// verified certificate. Destructive DatabaseService RPCs additionally
	// require a fingerprint in OperatorCertificateFingerprints. Requires
	// TlsCertFilePath/TlsKeyFilePath to also be set, since mTLS has no meaning
	// without the server's own TLS listener underneath it. Start (not NewBark)
	// fails closed if Lifecycle is set without these policies.
	TlsClientCAFilePath string
	// OperatorCertificateFingerprints is the explicit authorization policy for
	// destructive DatabaseService calls. Values are SHA-256 fingerprints of
	// client certificate DER bytes; hexadecimal values may contain colons and
	// are matched case-insensitively. Read-only DatabaseService calls require a
	// verified client certificate but do not require membership in this list.
	OperatorCertificateFingerprints []string
	// LifecycleOperatorCertificateFingerprints is the independent
	// authorization policy for LifecycleService Stop and Restart. GetStatus
	// requires a verified client certificate but not membership in this list.
	LifecycleOperatorCertificateFingerprints []string
	Host                                     string
	// Port is the TCP port to listen on. 0 selects a free port, which Addr
	// reports once Start has bound it.
	Port uint
	// CORSAllowedOrigins configures Access-Control-Allow-Origin.
	// Empty disables CORS.
	CORSAllowedOrigins []string
	// ArchiveMaxConcurrentFetches bounds how many ArchiveService.FetchBlock
	// requests run at once; a request over the limit is refused immediately
	// rather than queued. ArchiveService takes no client credentials, so this
	// and DefaultMaxFetchBlockRefs are what bound the work anyone who can
	// reach the listener can cause. Zero selects
	// DefaultMaxArchiveConcurrentFetches; a negative value is invalid.
	ArchiveMaxConcurrentFetches int
	// ArchiveLookupsPerSecond is the sustained rate of block lookups, each
	// of which can cost cloud storage requests, that ArchiveService serves
	// across all callers combined. A reference by hash or slot costs one
	// lookup; one by height alone also pays for the index search it runs
	// (see archiveHeightSearchLookups). A FetchBlock whose references do not
	// fit the remaining budget is refused whole, so the bucket is never
	// smaller than one maximum-size batch of hash or slot references. Zero
	// selects DefaultArchiveLookupsPerSecond; a negative value is invalid.
	ArchiveLookupsPerSecond int
	// ArchiveCallerLookupsPerSecond is the same rate for one caller, keyed
	// by IPv4 address or IPv6 /64, so a single client cannot spend the whole
	// global budget. Callers behind one proxy share an address and therefore
	// an allowance. Zero
	// selects DefaultArchiveCallerLookupsPerSecond; a negative value is
	// invalid.
	ArchiveCallerLookupsPerSecond int
}

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

type BlobStoreBarkConfig struct {
	BaseUrl                   string
	HTTPClient                *http.Client
	BlockDownloadAllowedHosts []string
	// BlockDownloadAllowPrivateAddresses permits the Bark service and block
	// downloads to use private, loopback, and other special-use addresses,
	// such as an archive and S3-compatible store on a private network. Origin,
	// HTTPS download, redirect, and proxy restrictions still apply. Defaults
	// to false.
	BlockDownloadAllowPrivateAddresses bool
	// MaxBlockSize reports the largest block, in bytes, an archive download may
	// carry. It is read on every download, so a limit that follows the live
	// protocol parameters stays current. A nil func, or a zero result, selects
	// the default cap.
	MaxBlockSize func() uint64
	// contains filtered or unexported fields
}

type NodeControl interface {
	// RequestShutdown accepts a graceful stop, or a stop followed by
	// re-execution when restart is true. A zero timeout selects the node's
	// default. It returns the timeout and deadline actually enforced, or
	// ErrShutdownInProgress / ErrRestartUnsupported.
	RequestShutdown(
		restart bool,
		timeout time.Duration,
	) (time.Duration, time.Time, error)
	// LifecycleStatus reports the node's lifecycle state, health, uptime,
	// version and chain synchronization state.
	LifecycleStatus() *lifecyclev1alpha1.GetStatusResponse
}