26361621328

Committed 24 May 2026 12:45PM UTC coverage: 82.525% (-0.09%) from 82.619%

Build # 26361621328

Build Type

Pull #1647

github

Committed by

web-flow

Commit Message

Merge 631aedab7 into bfc8bf728

Pull Request Pull Request #1647: add random backoff to avoid livelock

Coverage Stats

61 of 117 new or added lines in 3 files covered. (52.14%)

491 existing lines in 29 files now uncovered.

35801 of 43382 relevant lines covered (82.53%)

17.34 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.94

/token/services/storage/db/sql/sqlite/driver.go

/*
Copyright IBM Corp. All Rights Reserved.

SPDX-License-Identifier: Apache-2.0
*/

package sqlite

import (
        "strings"

        "github.com/hyperledger-labs/fabric-smart-client/platform/common/utils"
        "github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/cache/secondcache"
        "github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/lazy"
        driver2 "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/storage/driver"
        "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/storage/driver/common"
        fscSqlite "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/storage/driver/sql/sqlite"

        driver3 "github.com/hyperledger-labs/fabric-token-sdk/token/services/storage/db/driver"
        common2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/storage/db/sql/common"
)

type configProvider interface {
        GetOpts(name driver2.PersistenceName, params ...string) (*fscSqlite.Config, error)
}

type Driver struct {
        cp configProvider

        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]
        KeyStore  lazy.Provider[fscSqlite.Config, *KeystoreStore]
}

func NewNamedDriver(config driver3.Config, dbProvider fscSqlite.DbProvider) driver3.NamedDriver {
        return driver3.NamedDriver{
                Name:   fscSqlite.Persistence,
                Driver: NewDriverWithDbProvider(config, dbProvider),
        }
}

func NewDriver(config driver3.Config) *Driver {
        return NewDriverWithDbProvider(config, fscSqlite.NewDbProvider())
}

func NewDriverWithDbProvider(config driver3.Config, dbProvider fscSqlite.DbProvider) *Driver {
        d := &Driver{
                cp: fscSqlite.NewConfigProvider(common.NewConfig(config)),
        }

        d.TokenLock = newProviderWithKeyMapper(dbProvider, NewTokenLockStore)
        d.Wallet = newProviderWithKeyMapper(dbProvider, NewWalletStore)
        d.Identity = newIdentityStoreProvider(dbProvider)
        d.Token = newProviderWithKeyMapper(dbProvider, NewTokenStore)
        d.AuditTx = newProviderWithKeyMapper(dbProvider, NewAuditTransactionStore)
        d.OwnerTx = newProviderWithKeyMapper(dbProvider, NewTransactionStore)
        d.KeyStore = newProviderWithKeyMapper(dbProvider, NewKeystoreStore)

        return d
}

func newIdentityStoreProvider(dbProvider fscSqlite.DbProvider) lazy.Provider[fscSqlite.Config, *IdentityStore] {
        return lazy.NewProviderWithKeyMapper(key, func(o fscSqlite.Config) (*IdentityStore, error) {
                opts := fscSqlite.Opts{
                        DataSource:      o.DataSource,
                        SkipPragmas:     o.SkipPragmas,
                        MaxOpenConns:    o.MaxOpenConns,
                        MaxIdleConns:    *o.MaxIdleConns,
                        MaxIdleTime:     *o.MaxIdleTime,
                        TablePrefix:     o.TablePrefix,
                        TableNameParams: o.TableNameParams,
                        Tracing:         o.Tracing,
                }
                dbs, err := dbProvider.Get(opts)
                if err != nil {
                        return nil, err
                }
                tableNames, err := common2.GetTableNames(o.TablePrefix, o.TableNameParams...)
                if err != nil {
                        return nil, err
                }

                p, err := common2.NewIdentityStoreWithNotifier(
                        dbs.ReadDB,
                        dbs.WriteDB,
                        tableNames,
                        secondcache.NewTyped[bool](5000),
                        secondcache.NewTyped[[]byte](5000),
                        NewConditionInterpreter(),
                        &fscSqlite.ErrorMapper{},
                        nil,
                )
                if err != nil {
                        return nil, err
                }
                if !o.SkipCreateTable {
                        if err := p.CreateSchema(); err != nil {
                                return nil, err
                        }
                }

                return p, nil
        })
}

func (d *Driver) NewTokenLock(name driver2.PersistenceName, params ...string) (driver3.TokenLockStore, error) {
        opts, err := d.cp.GetOpts(name, params...)
        if err != nil {
                return nil, err
        }

        return d.TokenLock.Get(*opts)
}

func (d *Driver) NewWallet(name driver2.PersistenceName, params ...string) (driver3.WalletStore, error) {
        opts, err := d.cp.GetOpts(name, params...)
        if err != nil {
                return nil, err
        }

        return d.Wallet.Get(*opts)
}

func (d *Driver) NewIdentity(name driver2.PersistenceName, params ...string) (driver3.IdentityStore, error) {
        opts, err := d.cp.GetOpts(name, params...)
        if err != nil {
                return nil, err
        }

        return d.Identity.Get(*opts)
}

func (d *Driver) NewKeyStore(name driver2.PersistenceName, params ...string) (driver3.KeyStore, error) {
        opts, err := d.cp.GetOpts(name, params...)
        if err != nil {
                return nil, err
        }

        return d.KeyStore.Get(*opts)
}

func (d *Driver) NewToken(name driver2.PersistenceName, params ...string) (driver3.TokenStore, error) {
        opts, err := d.cp.GetOpts(name, params...)
        if err != nil {
                return nil, err
        }

        return d.Token.Get(*opts)
}

func (d *Driver) NewAuditTransaction(name driver2.PersistenceName, params ...string) (driver3.AuditTransactionStore, error) {
        opts, err := d.cp.GetOpts(name, append(params, "aud")...)
        if err != nil {
                return nil, err
        }

        return d.AuditTx.Get(*opts)
}

func (d *Driver) NewOwnerTransaction(name driver2.PersistenceName, params ...string) (driver3.TokenTransactionStore, error) {
        opts, err := d.cp.GetOpts(name, params...)
        if err != nil {
                return nil, err
        }

        return d.OwnerTx.Get(*opts)
}

func newProviderWithKeyMapper[V common.DBObject](dbProvider fscSqlite.DbProvider, constructor common2.PersistenceConstructor[V]) lazy.Provider[fscSqlite.Config, V] {
        return lazy.NewProviderWithKeyMapper(key, func(o fscSqlite.Config) (V, error) {
                opts := fscSqlite.Opts{
                        DataSource:      o.DataSource,
                        SkipPragmas:     o.SkipPragmas,
                        MaxOpenConns:    o.MaxOpenConns,
                        MaxIdleConns:    *o.MaxIdleConns,
                        MaxIdleTime:     *o.MaxIdleTime,
                        TablePrefix:     o.TablePrefix,
                        TableNameParams: o.TableNameParams,
                        Tracing:         o.Tracing,
                }
                dbs, err := dbProvider.Get(opts)
                if err != nil {
                        return utils.Zero[V](), err
                }
                tableNames, err := common2.GetTableNames(o.TablePrefix, o.TableNameParams...)
                if err != nil {
                        return utils.Zero[V](), err
                }
                p, err := constructor(dbs, tableNames)
                if err != nil {
                        return utils.Zero[V](), err
                }
                if !o.SkipCreateTable {
                        if err := p.CreateSchema(); err != nil {
                                return utils.Zero[V](), err
                        }
                }

                return p, nil
        })
}

func key(k fscSqlite.Config) string {
        return "sqlite" + k.DataSource + k.TablePrefix + strings.Join(k.TableNameParams, "_")
}

1	/*
2	Copyright IBM Corp. All Rights Reserved.
3
4	SPDX-License-Identifier: Apache-2.0
5	*/
6
7	package sqlite
8
9	import (
10	"strings"
11
12	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils"
13	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/cache/secondcache"
14	"github.com/hyperledger-labs/fabric-smart-client/platform/common/utils/lazy"
15	driver2 "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/storage/driver"
16	"github.com/hyperledger-labs/fabric-smart-client/platform/view/services/storage/driver/common"
17	fscSqlite "github.com/hyperledger-labs/fabric-smart-client/platform/view/services/storage/driver/sql/sqlite"
18
19	driver3 "github.com/hyperledger-labs/fabric-token-sdk/token/services/storage/db/driver"
20	common2 "github.com/hyperledger-labs/fabric-token-sdk/token/services/storage/db/sql/common"
21	)
22
23	type configProvider interface {
24	GetOpts(name driver2.PersistenceName, params ...string) (*fscSqlite.Config, error)
25	}
26
27	type Driver struct {
28	cp configProvider
29
30	TokenLock lazy.Provider[fscSqlite.Config, *TokenLockStore]
31	Wallet lazy.Provider[fscSqlite.Config, *WalletStore]
32	Identity lazy.Provider[fscSqlite.Config, *IdentityStore]
33	Token lazy.Provider[fscSqlite.Config, *TokenStore]
34	AuditTx lazy.Provider[fscSqlite.Config, *AuditTransactionStore]
35	OwnerTx lazy.Provider[fscSqlite.Config, *OwnerTransactionStore]
36	KeyStore lazy.Provider[fscSqlite.Config, *KeystoreStore]
37	}
38
39	func NewNamedDriver(config driver3.Config, dbProvider fscSqlite.DbProvider) driver3.NamedDriver {	49✔
40	return driver3.NamedDriver{	49✔
41	Name: fscSqlite.Persistence,	49✔
42	Driver: NewDriverWithDbProvider(config, dbProvider),	49✔
43	}	49✔
44	}	49✔
45
46	func NewDriver(config driver3.Config) *Driver {	43✔
47	return NewDriverWithDbProvider(config, fscSqlite.NewDbProvider())	43✔
48	}	43✔
49
50	func NewDriverWithDbProvider(config driver3.Config, dbProvider fscSqlite.DbProvider) *Driver {	53✔
51	d := &Driver{	53✔
52	cp: fscSqlite.NewConfigProvider(common.NewConfig(config)),	53✔
53	}	53✔
54		53✔
55	d.TokenLock = newProviderWithKeyMapper(dbProvider, NewTokenLockStore)	53✔
56	d.Wallet = newProviderWithKeyMapper(dbProvider, NewWalletStore)	53✔
57	d.Identity = newIdentityStoreProvider(dbProvider)	53✔
58	d.Token = newProviderWithKeyMapper(dbProvider, NewTokenStore)	53✔
59	d.AuditTx = newProviderWithKeyMapper(dbProvider, NewAuditTransactionStore)	53✔
60	d.OwnerTx = newProviderWithKeyMapper(dbProvider, NewTransactionStore)	53✔
61	d.KeyStore = newProviderWithKeyMapper(dbProvider, NewKeystoreStore)	53✔
62		53✔
63	return d	53✔
64	}	53✔
65
66	func newIdentityStoreProvider(dbProvider fscSqlite.DbProvider) lazy.Provider[fscSqlite.Config, *IdentityStore] {	53✔
67	return lazy.NewProviderWithKeyMapper(key, func(o fscSqlite.Config) (*IdentityStore, error) {	97✔
68	opts := fscSqlite.Opts{	44✔
69	DataSource: o.DataSource,	44✔
70	SkipPragmas: o.SkipPragmas,	44✔
71	MaxOpenConns: o.MaxOpenConns,	44✔
72	MaxIdleConns: *o.MaxIdleConns,	44✔
73	MaxIdleTime: *o.MaxIdleTime,	44✔
74	TablePrefix: o.TablePrefix,	44✔
75	TableNameParams: o.TableNameParams,	44✔
76	Tracing: o.Tracing,	44✔
77	}	44✔
78	dbs, err := dbProvider.Get(opts)	44✔
79	if err != nil {	44✔
80	return nil, err	×
UNCOV 81	}	×
82	tableNames, err := common2.GetTableNames(o.TablePrefix, o.TableNameParams...)	44✔
83	if err != nil {	44✔
84	return nil, err	×
UNCOV 85	}	×
86
87	p, err := common2.NewIdentityStoreWithNotifier(	44✔
88	dbs.ReadDB,	44✔
89	dbs.WriteDB,	44✔
90	tableNames,	44✔
91	secondcache.NewTyped[bool](5000),	44✔
92	secondcache.NewTyped[[]byte](5000),	44✔
93	NewConditionInterpreter(),	44✔
94	&fscSqlite.ErrorMapper{},	44✔
95	nil,	44✔
96	)	44✔
97	if err != nil {	44✔
98	return nil, err	×
UNCOV 99	}	×
100	if !o.SkipCreateTable {	88✔
101	if err := p.CreateSchema(); err != nil {	44✔
102	return nil, err	×
UNCOV 103	}	×
104	}
105
106	return p, nil	44✔
107	})
108	}
109
110	func (d *Driver) NewTokenLock(name driver2.PersistenceName, params ...string) (driver3.TokenLockStore, error) {	39✔
111	opts, err := d.cp.GetOpts(name, params...)	39✔
112	if err != nil {	39✔
113	return nil, err	×
UNCOV 114	}	×
115
116	return d.TokenLock.Get(*opts)	39✔
117	}
118
119	func (d *Driver) NewWallet(name driver2.PersistenceName, params ...string) (driver3.WalletStore, error) {	42✔
120	opts, err := d.cp.GetOpts(name, params...)	42✔
121	if err != nil {	42✔
122	return nil, err	×
UNCOV 123	}	×
124
125	return d.Wallet.Get(*opts)	42✔
126	}
127
128	func (d *Driver) NewIdentity(name driver2.PersistenceName, params ...string) (driver3.IdentityStore, error) {	42✔
129	opts, err := d.cp.GetOpts(name, params...)	42✔
130	if err != nil {	42✔
131	return nil, err	×
UNCOV 132	}	×
133
134	return d.Identity.Get(*opts)	42✔
135	}
136
137	func (d *Driver) NewKeyStore(name driver2.PersistenceName, params ...string) (driver3.KeyStore, error) {	42✔
138	opts, err := d.cp.GetOpts(name, params...)	42✔
139	if err != nil {	42✔
140	return nil, err	×
UNCOV 141	}	×
142
143	return d.KeyStore.Get(*opts)	42✔
144	}
145
146	func (d *Driver) NewToken(name driver2.PersistenceName, params ...string) (driver3.TokenStore, error) {	43✔
147	opts, err := d.cp.GetOpts(name, params...)	43✔
148	if err != nil {	43✔
149	return nil, err	×
UNCOV 150	}	×
151
152	return d.Token.Get(*opts)	43✔
153	}
154
155	func (d *Driver) NewAuditTransaction(name driver2.PersistenceName, params ...string) (driver3.AuditTransactionStore, error) {	39✔
156	opts, err := d.cp.GetOpts(name, append(params, "aud")...)	39✔
157	if err != nil {	39✔
158	return nil, err	×
UNCOV 159	}	×
160
161	return d.AuditTx.Get(*opts)	39✔
162	}
163
164	func (d *Driver) NewOwnerTransaction(name driver2.PersistenceName, params ...string) (driver3.TokenTransactionStore, error) {	43✔
165	opts, err := d.cp.GetOpts(name, params...)	43✔
166	if err != nil {	43✔
167	return nil, err	×
UNCOV 168	}	×
169
170	return d.OwnerTx.Get(*opts)	43✔
171	}
172
173	func newProviderWithKeyMapper[V common.DBObject](dbProvider fscSqlite.DbProvider, constructor common2.PersistenceConstructor[V]) lazy.Provider[fscSqlite.Config, V] {	53✔
174	return lazy.NewProviderWithKeyMapper(key, func(o fscSqlite.Config) (V, error) {	104✔
175	opts := fscSqlite.Opts{	51✔
176	DataSource: o.DataSource,	51✔
177	SkipPragmas: o.SkipPragmas,	51✔
178	MaxOpenConns: o.MaxOpenConns,	51✔
179	MaxIdleConns: *o.MaxIdleConns,	51✔
180	MaxIdleTime: *o.MaxIdleTime,	51✔
181	TablePrefix: o.TablePrefix,	51✔
182	TableNameParams: o.TableNameParams,	51✔
183	Tracing: o.Tracing,	51✔
184	}	51✔
185	dbs, err := dbProvider.Get(opts)	51✔
186	if err != nil {	51✔
187	return utils.Zero[V](), err	×
UNCOV 188	}	×
189	tableNames, err := common2.GetTableNames(o.TablePrefix, o.TableNameParams...)	51✔
190	if err != nil {	51✔
191	return utils.Zero[V](), err	×
UNCOV 192	}	×
193	p, err := constructor(dbs, tableNames)	51✔
194	if err != nil {	51✔
195	return utils.Zero[V](), err	×
UNCOV 196	}	×
197	if !o.SkipCreateTable {	102✔
198	if err := p.CreateSchema(); err != nil {	51✔
199	return utils.Zero[V](), err	×
UNCOV 200	}	×
201	}
202
203	return p, nil	51✔
204	})
205	}
206
207	func key(k fscSqlite.Config) string {	53✔
208	return "sqlite" + k.DataSource + k.TablePrefix + strings.Join(k.TableNameParams, "_")	53✔
209	}	53✔

hyperledger-labs / fabric-token-sdk / 26361621328

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous