sqlite

type AuditTransactionStore ¶

type AuditTransactionStore = common3.TransactionStore

func NewAuditTransactionStore(dbs *common2.RWDB, tableNames common3.TableNames) (*AuditTransactionStore, error)

type BusyRetryWriteDB ¶ added in v0.24.0

type BusyRetryWriteDB struct {
	*sql.DB
	// contains filtered or unexported fields
}

BusyRetryWriteDB decorates a SQLite write pool so that a statement rejected with SQLITE_BUSY is retried a bounded number of times instead of surfacing to the caller.

Without it, write contention beyond busy_timeout reaches Panurus as a raw SQLITE_BUSY: FSC wraps its own stores this way but nothing wrapped Panurus's, so the token, token-lock, wallet, identity, keystore, transaction and endorser stores all propagated it. That bites single-node deployments under concurrent writes, and the in-memory driver most of all - it is this driver, on file::memory:?cache=shared, where every store's write pool contends for one shared cache.

It differs from FSC's retryWriteDB in being bounded: that one recurses on every SQLITE_BUSY with no limit and no backoff, so a lock held for good turns into an unbounded retry loop growing the stack.

Only Exec and ExecContext are decorated. Begin and BeginTx are promoted from the embedded pool and hand out a raw *sql.Tx, so statements inside a transaction still see SQLITE_BUSY: replaying those means replaying the whole transaction, which only the caller can decide to do.

func NewBusyRetryWriteDB(db *sql.DB) *BusyRetryWriteDB

func (db *BusyRetryWriteDB) Exec(query string, args ...any) (sql.Result, error)

func (db *BusyRetryWriteDB) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)

type Driver ¶

type Driver struct {
	TokenLock lazy.Provider[fscSqlite.Config, *TokenLockStore]
	Wallet    lazy.Provider[fscSqlite.Config, *WalletStore]
	Identity  lazy.Provider[fscSqlite.Config, *IdentityStore]
	Token     lazy.Provider[fscSqlite.Config, *TokenStore]
	AuditTx   lazy.Provider[fscSqlite.Config, *AuditTransactionStore]
	OwnerTx   lazy.Provider[fscSqlite.Config, *OwnerTransactionStore]
	Endorser  lazy.Provider[fscSqlite.Config, *EndorserStore]
	KeyStore  lazy.Provider[fscSqlite.Config, *KeystoreStore]
	// contains filtered or unexported fields
}

func NewDriver(config driver3.Config) *Driver

func NewDriverWithDbProvider(config driver3.Config, dbProvider fscSqlite.DbProvider) *Driver

func (d *Driver) NewAuditTransaction(name driver2.PersistenceName, params ...string) (driver3.AuditTransactionStore, error)

func (d *Driver) NewEndorser(name driver2.PersistenceName, params ...string) (driver3.EndorserStore, error)

func (d *Driver) NewIdentity(name driver2.PersistenceName, params ...string) (driver3.IdentityStore, error)

func (d *Driver) NewKeyStore(name driver2.PersistenceName, params ...string) (driver3.KeyStore, error)

func (d *Driver) NewOwnerTransaction(name driver2.PersistenceName, params ...string) (driver3.TokenTransactionStore, error)

func (d *Driver) NewToken(name driver2.PersistenceName, params ...string) (driver3.TokenStore, error)

func (d *Driver) NewTokenLock(name driver2.PersistenceName, params ...string) (driver3.TokenLockStore, error)

func (d *Driver) NewWallet(name driver2.PersistenceName, params ...string) (driver3.WalletStore, error)

type EndorserStore ¶

type EndorserStore = common.EndorserStore

func NewEndorserStore(dbs *common2.RWDB, tables common.TableNames) (*EndorserStore, error)

type IdentityStore ¶

type IdentityStore = sqlcommon.IdentityStore

type KeystoreStore ¶

type KeystoreStore = common3.KeystoreStore

func NewKeystoreStore(dbs *common2.RWDB, tableNames common3.TableNames) (*KeystoreStore, error)

type OwnerTransactionStore ¶

type OwnerTransactionStore = common3.TransactionStore

func NewTransactionStore(dbs *common2.RWDB, tableNames common3.TableNames) (*OwnerTransactionStore, error)

type TokenLockStore ¶

type TokenLockStore struct {
	*common4.TokenLockStore
}

TokenLockStore implements the token lock storage for SQLite. Cleanup is inherited from the embedded store, so lease expiry is identical to the other SQL backends.

func NewTokenLockStore(dbs *common3.RWDB, tableNames common4.TableNames) (*TokenLockStore, error)

func (db *TokenLockStore) AcquireCleanupLeadership(_ context.Context) (driver.CleanupLeadership, bool, error)

type TokenStore ¶

type TokenStore = sqlcommon.TokenStore

func NewTokenStore(
	dbs *scommon.RWDB,
	tableNames sqlcommon.TableNames,
) (*TokenStore, error)

type WalletStore ¶

type WalletStore = common3.WalletStore

func NewWalletStore(dbs *common2.RWDB, tableNames common3.TableNames) (*WalletStore, error)