cassandra

type BlobStore interface {
	// Get or fetch a blob given an ID.
	GetOne(ctx context.Context, blobTable string, blobID sop.UUID, target interface{}) error
	// Add blobs to store.
	Add(ctx context.Context, blobs ...BlobsPayload[sop.KeyValuePair[sop.UUID, interface{}]]) error
	// Update blobs in store.
	Update(ctx context.Context, blobs ...BlobsPayload[sop.KeyValuePair[sop.UUID, interface{}]]) error
	// Remove blobs in store with given IDs.
	Remove(ctx context.Context, blobsIDs ...BlobsPayload[sop.UUID]) error
}

type BlobsPayload[T sop.UUID | sop.KeyValuePair[sop.UUID, interface{}]] struct {
	// Blob store table name.
	BlobTable string
	// Blobs contains the blobs IDs and blobs data for upsert to the store or the blobs IDs to be removed.
	Blobs []T
}

type Config struct {
	// Cassandra hosts cluster.
	ClusterHosts []string
	// Keyspace to be used when doing I/O to cassandra.
	Keyspace string
	// Default Consistency level.
	Consistency gocql.Consistency
	// Connection Timeout.
	ConnectionTimeout time.Duration
	// Authenticator.
	Authenticator gocql.Authenticator
	// Defaults to "simple strategy & replication factor of 1".
	ReplicationClause string

	// ConsistencyBook should be used to specify consistency level to use for a given
	// API, e.g. one for RegistryAdd, another for StoreAdd, etc... if you so choose to.
	//
	// You can leave it default and the API will use the default Consistency level
	// for the cluster (defaults to local quorum).
	ConsistencyBook ConsistencyBook
}

type Connection struct {
	Session *gocql.Session
	Config
}

type ConsistencyBook struct {
	RegistryAdd     gocql.Consistency
	RegistryUpdate  gocql.Consistency
	RegistryGet     gocql.Consistency
	RegistryRemove  gocql.Consistency
	StoreAdd        gocql.Consistency
	StoreUpdate     gocql.Consistency
	StoreGet        gocql.Consistency
	StoreRemove     gocql.Consistency
	BlobStoreAdd    gocql.Consistency
	BlobStoreGet    gocql.Consistency
	BlobStoreUpdate gocql.Consistency
	BlobStoreRemove gocql.Consistency
}

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

type Mock_vid_registry struct {
	Lookup                           map[sop.UUID]sop.Handle
	InducedErrorOnUpdateAllOrNothing bool
}

type Registry interface {
	// Get will fetch handles(given their IDs) from registry table(s).
	Get(context.Context, ...RegistryPayload[sop.UUID]) ([]RegistryPayload[sop.Handle], error)
	// Add will insert handles to registry table(s).
	Add(context.Context, ...RegistryPayload[sop.Handle]) error
	// Update will update handles potentially spanning across registry table(s).
	// Set allOrNothing to true if Update operation is crucial for data consistency and
	// wanting to do an all or nothing update for the entire batch of handles.
	// False is recommended if such consistency is not significant.
	Update(ctx context.Context, allOrNothing bool, handles ...RegistryPayload[sop.Handle]) error
	// Remove will delete handles(given their IDs) from registry table(s).
	Remove(context.Context, ...RegistryPayload[sop.UUID]) error
}

type RegistryPayload[T sop.Handle | sop.UUID] struct {
	// Registry table (name) where the Virtual IDs will be stored or fetched from.
	RegistryTable string
	// IDs is an array containing the Virtual IDs details to be stored or to be fetched.
	IDs []T
}

type StoreRepository interface {
	// Fetch store info with name.
	Get(context.Context, ...string) ([]btree.StoreInfo, error)
	// Add store info & create related tables like for registry & for node blob.
	Add(context.Context, ...btree.StoreInfo) error
	// Update store info. Update should also merge the Count of items between the incoming store info
	// and the target store info on the backend, as they may differ. It should use StoreInfo.CountDelta to reconcile the two.
	Update(context.Context, ...btree.StoreInfo) error
	// Remove store info with name & drop related tables like for registry & for node blob.
	Remove(context.Context, ...string) error
}

type TransactionLog interface {
	// Add a transaction log.
	Add(ctx context.Context, tid gocql.UUID, commitFunction int, payload []byte) error
	// Remove all logs of a given transaciton.
	Remove(ctx context.Context, tid gocql.UUID) error

	// GetOne will fetch the oldest transaction logs from the backend, older than 1 hour ago, mark it so succeeding call
	// will return the next hour and so on, until no more, upon reaching the current hour.
	//
	// GetOne behaves like a job distributor by the hour. SOP uses it to sprinkle/distribute task to cleanup
	// left over resources by unfinished transactions in time. Be it due to crash or host reboot, any transaction
	// temp resource will then age and reach expiration limit, then get cleaned up. This method is used to do distribution.
	//
	// It is capped to an hour ago older because anything newer may still be an in-flight or ongoing transaction.
	GetOne(ctx context.Context) (gocql.UUID, string, []sop.KeyValuePair[int, []byte], error)

	// Given a date hour, returns an available for cleanup set of transaction logs with their Transaction ID.
	// Or nils if there is no more needing cleanup for this date hour.
	GetLogsDetails(ctx context.Context, hour string) (gocql.UUID, []sop.KeyValuePair[int, []byte], error)
}

type UpdateAllOrNothingError struct {
	Err error
}