noth/surrealpatch
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use context.Context on all kvs requests

Browse source
This commit is contained in:
Tobie Morgan Hitchcock 2018-05-02 03:05:03 +01:00
parent b7d89ee65a
commit e3bea0a897
19 changed files with 281 additions and 251 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
db/check.go
View file

@ -76,7 +76,7 @@ func (d *document) grant(ctx context.Context, met method) (ok bool, err error) {
// so we can check if the permissions // so we can check if the permissions
// allow us to view this document. // allow us to view this document.
tb, err := d.getTB() tb, err := d.getTB(ctx)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -156,7 +156,7 @@ func (d *document) allow(ctx context.Context, met method) (ok bool, err error) {
// so we can check if the permissions // so we can check if the permissions
// allow us to view this document. // allow us to view this document.
tb, err := d.getTB() tb, err := d.getTB(ctx)
if err != nil { if err != nil {
return false, err return false, err
} }

48
db/define.go
View file

@ -28,7 +28,7 @@ func (e *executor) executeDefineNamespace(ctx context.Context, ast *sql.DefineNa
// Save the namespace definition // Save the namespace definition
nkey := &keys.NS{KV: ast.KV, NS: ast.Name.ID} nkey := &keys.NS{KV: ast.KV, NS: ast.Name.ID}
_, err = e.dbo.Put(0, nkey.Encode(), ast.Encode()) _, err = e.dbo.Put(ctx, 0, nkey.Encode(), ast.Encode())
return return
@ -36,11 +36,11 @@ func (e *executor) executeDefineNamespace(ctx context.Context, ast *sql.DefineNa
func (e *executor) executeDefineDatabase(ctx context.Context, ast *sql.DefineDatabaseStatement) (out []interface{}, err error) { func (e *executor) executeDefineDatabase(ctx context.Context, ast *sql.DefineDatabaseStatement) (out []interface{}, err error) {
e.dbo.AddNS(ast.NS) e.dbo.AddNS(ctx, ast.NS)
// Save the database definition // Save the database definition
dkey := &keys.DB{KV: ast.KV, NS: ast.NS, DB: ast.Name.ID} dkey := &keys.DB{KV: ast.KV, NS: ast.NS, DB: ast.Name.ID}
_, err = e.dbo.Put(0, dkey.Encode(), ast.Encode()) _, err = e.dbo.Put(ctx, 0, dkey.Encode(), ast.Encode())
return return
@ -55,19 +55,19 @@ func (e *executor) executeDefineLogin(ctx context.Context, ast *sql.DefineLoginS
switch ast.Kind { switch ast.Kind {
case sql.NAMESPACE: case sql.NAMESPACE:
e.dbo.AddNS(ast.NS) e.dbo.AddNS(ctx, ast.NS)
// Save the login definition // Save the login definition
ukey := &keys.NU{KV: ast.KV, NS: ast.NS, US: ast.User.ID} ukey := &keys.NU{KV: ast.KV, NS: ast.NS, US: ast.User.ID}
_, err = e.dbo.Put(0, ukey.Encode(), ast.Encode()) _, err = e.dbo.Put(ctx, 0, ukey.Encode(), ast.Encode())
case sql.DATABASE: case sql.DATABASE:
e.dbo.AddDB(ast.NS, ast.DB) e.dbo.AddDB(ctx, ast.NS, ast.DB)
// Save the login definition // Save the login definition
ukey := &keys.DU{KV: ast.KV, NS: ast.NS, DB: ast.DB, US: ast.User.ID} ukey := &keys.DU{KV: ast.KV, NS: ast.NS, DB: ast.DB, US: ast.User.ID}
_, err = e.dbo.Put(0, ukey.Encode(), ast.Encode()) _, err = e.dbo.Put(ctx, 0, ukey.Encode(), ast.Encode())
} }
@ -80,19 +80,19 @@ func (e *executor) executeDefineToken(ctx context.Context, ast *sql.DefineTokenS
switch ast.Kind { switch ast.Kind {
case sql.NAMESPACE: case sql.NAMESPACE:
e.dbo.AddNS(ast.NS) e.dbo.AddNS(ctx, ast.NS)
// Save the token definition // Save the token definition
tkey := &keys.NT{KV: ast.KV, NS: ast.NS, TK: ast.Name.ID} tkey := &keys.NT{KV: ast.KV, NS: ast.NS, TK: ast.Name.ID}
_, err = e.dbo.Put(0, tkey.Encode(), ast.Encode()) _, err = e.dbo.Put(ctx, 0, tkey.Encode(), ast.Encode())
case sql.DATABASE: case sql.DATABASE:
e.dbo.AddDB(ast.NS, ast.DB) e.dbo.AddDB(ctx, ast.NS, ast.DB)
// Save the token definition // Save the token definition
tkey := &keys.DT{KV: ast.KV, NS: ast.NS, DB: ast.DB, TK: ast.Name.ID} tkey := &keys.DT{KV: ast.KV, NS: ast.NS, DB: ast.DB, TK: ast.Name.ID}
_, err = e.dbo.Put(0, tkey.Encode(), ast.Encode()) _, err = e.dbo.Put(ctx, 0, tkey.Encode(), ast.Encode())
} }
@ -104,11 +104,11 @@ func (e *executor) executeDefineScope(ctx context.Context, ast *sql.DefineScopeS
ast.Code = rand.New(128) ast.Code = rand.New(128)
e.dbo.AddDB(ast.NS, ast.DB) e.dbo.AddDB(ctx, ast.NS, ast.DB)
// Remove the scope definition // Remove the scope definition
skey := &keys.SC{KV: ast.KV, NS: ast.NS, DB: ast.DB, SC: ast.Name.ID} skey := &keys.SC{KV: ast.KV, NS: ast.NS, DB: ast.DB, SC: ast.Name.ID}
_, err = e.dbo.Put(0, skey.Encode(), ast.Encode()) _, err = e.dbo.Put(ctx, 0, skey.Encode(), ast.Encode())
return return
@ -118,11 +118,11 @@ func (e *executor) executeDefineEvent(ctx context.Context, ast *sql.DefineEventS
for _, TB := range ast.What { for _, TB := range ast.What {
e.dbo.AddTB(ast.NS, ast.DB, TB.TB) e.dbo.AddTB(ctx, ast.NS, ast.DB, TB.TB)
// Remove the event definition // Remove the event definition
ekey := &keys.EV{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, EV: ast.Name.ID} ekey := &keys.EV{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, EV: ast.Name.ID}
if _, err = e.dbo.Put(0, ekey.Encode(), ast.Encode()); err != nil { if _, err = e.dbo.Put(ctx, 0, ekey.Encode(), ast.Encode()); err != nil {
return nil, err return nil, err
} }
@ -136,11 +136,11 @@ func (e *executor) executeDefineField(ctx context.Context, ast *sql.DefineFieldS
for _, TB := range ast.What { for _, TB := range ast.What {
e.dbo.AddTB(ast.NS, ast.DB, TB.TB) e.dbo.AddTB(ctx, ast.NS, ast.DB, TB.TB)
// Save the field definition // Save the field definition
fkey := &keys.FD{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, FD: ast.Name.ID} fkey := &keys.FD{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, FD: ast.Name.ID}
if _, err = e.dbo.Put(0, fkey.Encode(), ast.Encode()); err != nil { if _, err = e.dbo.Put(ctx, 0, fkey.Encode(), ast.Encode()); err != nil {
return nil, err return nil, err
} }
@ -154,17 +154,17 @@ func (e *executor) executeDefineIndex(ctx context.Context, ast *sql.DefineIndexS
for _, TB := range ast.What { for _, TB := range ast.What {
e.dbo.AddTB(ast.NS, ast.DB, TB.TB) e.dbo.AddTB(ctx, ast.NS, ast.DB, TB.TB)
// Save the index definition // Save the index definition
ikey := &keys.IX{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, IX: ast.Name.ID} ikey := &keys.IX{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, IX: ast.Name.ID}
if _, err = e.dbo.Put(0, ikey.Encode(), ast.Encode()); err != nil { if _, err = e.dbo.Put(ctx, 0, ikey.Encode(), ast.Encode()); err != nil {
return nil, err return nil, err
} }
// Remove the index resource data // Remove the index resource data
dkey := &keys.Index{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, IX: ast.Name.ID, FD: keys.Ignore} dkey := &keys.Index{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, IX: ast.Name.ID, FD: keys.Ignore}
if _, err = e.dbo.ClrP(dkey.Encode(), 0); err != nil { if _, err = e.dbo.ClrP(ctx, dkey.Encode(), 0); err != nil {
return nil, err return nil, err
} }
@ -183,7 +183,7 @@ func (e *executor) executeDefineIndex(ctx context.Context, ast *sql.DefineIndexS
func (e *executor) executeDefineTable(ctx context.Context, ast *sql.DefineTableStatement) (out []interface{}, err error) { func (e *executor) executeDefineTable(ctx context.Context, ast *sql.DefineTableStatement) (out []interface{}, err error) {
e.dbo.AddDB(ast.NS, ast.DB) e.dbo.AddDB(ctx, ast.NS, ast.DB)
for _, TB := range ast.What { for _, TB := range ast.What {
@ -191,7 +191,7 @@ func (e *executor) executeDefineTable(ctx context.Context, ast *sql.DefineTableS
// Save the table definition // Save the table definition
tkey := &keys.TB{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB} tkey := &keys.TB{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB}
if _, err = e.dbo.Put(0, tkey.Encode(), ast.Encode()); err != nil { if _, err = e.dbo.Put(ctx, 0, tkey.Encode(), ast.Encode()); err != nil {
return nil, err return nil, err
} }
@ -199,7 +199,7 @@ func (e *executor) executeDefineTable(ctx context.Context, ast *sql.DefineTableS
// Remove the table resource data // Remove the table resource data
dkey := &keys.Table{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB} dkey := &keys.Table{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB}
if _, err = e.dbo.ClrP(dkey.Encode(), 0); err != nil { if _, err = e.dbo.ClrP(ctx, dkey.Encode(), 0); err != nil {
return nil, err return nil, err
} }
@ -207,7 +207,7 @@ func (e *executor) executeDefineTable(ctx context.Context, ast *sql.DefineTableS
// Save the foreign table definition // Save the foreign table definition
tkey := &keys.FT{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: FT.TB, FT: TB.TB} tkey := &keys.FT{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: FT.TB, FT: TB.TB}
if _, err = e.dbo.Put(0, tkey.Encode(), ast.Encode()); err != nil { if _, err = e.dbo.Put(ctx, 0, tkey.Encode(), ast.Encode()); err != nil {
return nil, err return nil, err
} }

50
db/document.go
View file

@ -92,50 +92,50 @@ func (d *document) erase() (err error) {
return return
} }
func (d *document) getTB() (out *sql.DefineTableStatement, err error) { func (d *document) getTB(ctx context.Context) (out *sql.DefineTableStatement, err error) {
if !d.store.tb { if !d.store.tb {
d.store.tb = true d.store.tb = true
d.cache.tb, err = d.i.e.dbo.GetTB(d.key.NS, d.key.DB, d.key.TB) d.cache.tb, err = d.i.e.dbo.GetTB(ctx, d.key.NS, d.key.DB, d.key.TB)
} }
return d.cache.tb, err return d.cache.tb, err
} }
func (d *document) getEV() (out []*sql.DefineEventStatement, err error) { func (d *document) getEV(ctx context.Context) (out []*sql.DefineEventStatement, err error) {
if !d.store.ev { if !d.store.ev {
d.store.ev = true d.store.ev = true
d.cache.ev, err = d.i.e.dbo.AllEV(d.key.NS, d.key.DB, d.key.TB) d.cache.ev, err = d.i.e.dbo.AllEV(ctx, d.key.NS, d.key.DB, d.key.TB)
} }
return d.cache.ev, err return d.cache.ev, err
} }
func (d *document) getFD() (out []*sql.DefineFieldStatement, err error) { func (d *document) getFD(ctx context.Context) (out []*sql.DefineFieldStatement, err error) {
if !d.store.fd { if !d.store.fd {
d.store.fd = true d.store.fd = true
d.cache.fd, err = d.i.e.dbo.AllFD(d.key.NS, d.key.DB, d.key.TB) d.cache.fd, err = d.i.e.dbo.AllFD(ctx, d.key.NS, d.key.DB, d.key.TB)
} }
return d.cache.fd, err return d.cache.fd, err
} }
func (d *document) getIX() (out []*sql.DefineIndexStatement, err error) { func (d *document) getIX(ctx context.Context) (out []*sql.DefineIndexStatement, err error) {
if !d.store.ix { if !d.store.ix {
d.store.ix = true d.store.ix = true
d.cache.ix, err = d.i.e.dbo.AllIX(d.key.NS, d.key.DB, d.key.TB) d.cache.ix, err = d.i.e.dbo.AllIX(ctx, d.key.NS, d.key.DB, d.key.TB)
} }
return d.cache.ix, err return d.cache.ix, err
} }
func (d *document) getFT() (out []*sql.DefineTableStatement, err error) { func (d *document) getFT(ctx context.Context) (out []*sql.DefineTableStatement, err error) {
if !d.store.ft { if !d.store.ft {
d.store.ft = true d.store.ft = true
d.cache.ft, err = d.i.e.dbo.AllFT(d.key.NS, d.key.DB, d.key.TB) d.cache.ft, err = d.i.e.dbo.AllFT(ctx, d.key.NS, d.key.DB, d.key.TB)
} }
return d.cache.ft, err return d.cache.ft, err
} }
func (d *document) getLV() (out []*sql.LiveStatement, err error) { func (d *document) getLV(ctx context.Context) (out []*sql.LiveStatement, err error) {
if !d.store.lv { if !d.store.lv {
d.store.lv = true d.store.lv = true
d.cache.lv, err = d.i.e.dbo.AllLV(d.key.NS, d.key.DB, d.key.TB) d.cache.lv, err = d.i.e.dbo.AllLV(ctx, d.key.NS, d.key.DB, d.key.TB)
} }
return d.cache.lv, err return d.cache.lv, err
} }
@ -224,7 +224,7 @@ func (d *document) setup(ctx context.Context) (err error) {
// to be loaded from the KV store. // to be loaded from the KV store.
if d.key != nil && d.val == nil { if d.key != nil && d.val == nil {
d.val, err = d.i.e.dbo.Get(d.i.versn, d.key.Encode()) d.val, err = d.i.e.dbo.Get(ctx, d.i.versn, d.key.Encode())
if err != nil { if err != nil {
return return
} }
@ -332,7 +332,7 @@ func (d *document) shouldDrop(ctx context.Context) (bool, error) {
// that the table should drop // that the table should drop
// writes, and if so, then return. // writes, and if so, then return.
tb, err := d.getTB() tb, err := d.getTB(ctx)
if err != nil { if err != nil {
return false, err return false, err
} }
@ -362,7 +362,7 @@ func (d *document) storeThing(ctx context.Context) (err error) {
// Write the value to the data // Write the value to the data
// layer and return any errors. // layer and return any errors.
_, err = d.i.e.dbo.Put(d.i.e.time, d.key.Encode(), d.current.Encode()) _, err = d.i.e.dbo.Put(ctx, d.i.e.time, d.key.Encode(), d.current.Encode())
return return
@ -382,7 +382,7 @@ func (d *document) purgeThing(ctx context.Context) (err error) {
// Reset the item by writing a // Reset the item by writing a
// nil value to the storage. // nil value to the storage.
_, err = d.i.e.dbo.Put(d.i.e.time, d.key.Encode(), nil) _, err = d.i.e.dbo.Put(ctx, d.i.e.time, d.key.Encode(), nil)
return return
@ -402,7 +402,7 @@ func (d *document) eraseThing(ctx context.Context) (err error) {
// Delete the item entirely from // Delete the item entirely from
// storage, so no versions exist. // storage, so no versions exist.
_, err = d.i.e.dbo.Clr(d.key.Encode()) _, err = d.i.e.dbo.Clr(ctx, d.key.Encode())
return return
@ -433,7 +433,7 @@ func (d *document) storeIndex(ctx context.Context) (err error) {
// for this table, loop through // for this table, loop through
// them, and compute the changes. // them, and compute the changes.
ixs, err := d.getIX() ixs, err := d.getIX(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -450,11 +450,11 @@ func (d *document) storeIndex(ctx context.Context) (err error) {
if ix.Uniq == true { if ix.Uniq == true {
for _, v := range del { for _, v := range del {
didx := &keys.Index{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v} didx := &keys.Index{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v}
d.i.e.dbo.DelC(d.i.e.time, didx.Encode(), d.id.Bytes()) d.i.e.dbo.DelC(ctx, d.i.e.time, didx.Encode(), d.id.Bytes())
} }
for _, v := range add { for _, v := range add {
aidx := &keys.Index{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v} aidx := &keys.Index{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v}
if _, err = d.i.e.dbo.PutC(0, aidx.Encode(), d.id.Bytes(), nil); err != nil { if _, err = d.i.e.dbo.PutC(ctx, 0, aidx.Encode(), d.id.Bytes(), nil); err != nil {
return &IndexError{tb: d.key.TB, name: ix.Name, cols: ix.Cols, vals: v} return &IndexError{tb: d.key.TB, name: ix.Name, cols: ix.Cols, vals: v}
} }
} }
@ -463,11 +463,11 @@ func (d *document) storeIndex(ctx context.Context) (err error) {
if ix.Uniq == false { if ix.Uniq == false {
for _, v := range del { for _, v := range del {
didx := &keys.Point{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v, ID: d.key.ID} didx := &keys.Point{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v, ID: d.key.ID}
d.i.e.dbo.DelC(d.i.e.time, didx.Encode(), d.id.Bytes()) d.i.e.dbo.DelC(ctx, d.i.e.time, didx.Encode(), d.id.Bytes())
} }
for _, v := range add { for _, v := range add {
aidx := &keys.Point{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v, ID: d.key.ID} aidx := &keys.Point{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v, ID: d.key.ID}
if _, err = d.i.e.dbo.PutC(0, aidx.Encode(), d.id.Bytes(), nil); err != nil { if _, err = d.i.e.dbo.PutC(ctx, 0, aidx.Encode(), d.id.Bytes(), nil); err != nil {
return &IndexError{tb: d.key.TB, name: ix.Name, cols: ix.Cols, vals: v} return &IndexError{tb: d.key.TB, name: ix.Name, cols: ix.Cols, vals: v}
} }
} }
@ -504,7 +504,7 @@ func (d *document) purgeIndex(ctx context.Context) (err error) {
// for this table, loop through // for this table, loop through
// them, and compute the changes. // them, and compute the changes.
ixs, err := d.getIX() ixs, err := d.getIX(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -516,14 +516,14 @@ func (d *document) purgeIndex(ctx context.Context) (err error) {
if ix.Uniq == true { if ix.Uniq == true {
for _, v := range del { for _, v := range del {
key := &keys.Index{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v} key := &keys.Index{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v}
d.i.e.dbo.DelC(0, key.Encode(), d.id.Bytes()) d.i.e.dbo.DelC(ctx, 0, key.Encode(), d.id.Bytes())
} }
} }
if ix.Uniq == false { if ix.Uniq == false {
for _, v := range del { for _, v := range del {
key := &keys.Point{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v, ID: d.key.ID} key := &keys.Point{KV: d.key.KV, NS: d.key.NS, DB: d.key.DB, TB: d.key.TB, IX: ix.Name.ID, FD: v, ID: d.key.ID}
d.i.e.dbo.DelC(0, key.Encode(), d.id.Bytes()) d.i.e.dbo.DelC(ctx, 0, key.Encode(), d.id.Bytes())
} }
} }

2
db/event.go
View file

@ -43,7 +43,7 @@ func (d *document) event(ctx context.Context, met method) (err error) {
// for this table, loop through // for this table, loop through
// them, and compute the events. // them, and compute the events.
evs, err := d.getEV() evs, err := d.getEV(ctx)
if err != nil { if err != nil {
return err return err
} }

24
db/info.go
View file

@ -38,17 +38,17 @@ func (e *executor) executeInfo(ctx context.Context, ast *sql.InfoStatement) (out
func (e *executor) executeInfoNS(ctx context.Context, ast *sql.InfoStatement) (out []interface{}, err error) { func (e *executor) executeInfoNS(ctx context.Context, ast *sql.InfoStatement) (out []interface{}, err error) {
db, err := e.dbo.AllDB(ast.NS) db, err := e.dbo.AllDB(ctx, ast.NS)
if err != nil { if err != nil {
return nil, err return nil, err
} }
nt, err := e.dbo.AllNT(ast.NS) nt, err := e.dbo.AllNT(ctx, ast.NS)
if err != nil { if err != nil {
return nil, err return nil, err
} }
nu, err := e.dbo.AllNU(ast.NS) nu, err := e.dbo.AllNU(ctx, ast.NS)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -80,22 +80,22 @@ func (e *executor) executeInfoNS(ctx context.Context, ast *sql.InfoStatement) (o
func (e *executor) executeInfoDB(ctx context.Context, ast *sql.InfoStatement) (out []interface{}, err error) { func (e *executor) executeInfoDB(ctx context.Context, ast *sql.InfoStatement) (out []interface{}, err error) {
tb, err := e.dbo.AllTB(ast.NS, ast.DB) tb, err := e.dbo.AllTB(ctx, ast.NS, ast.DB)
if err != nil { if err != nil {
return nil, err return nil, err
} }
dt, err := e.dbo.AllDT(ast.NS, ast.DB) dt, err := e.dbo.AllDT(ctx, ast.NS, ast.DB)
if err != nil { if err != nil {
return nil, err return nil, err
} }
du, err := e.dbo.AllDU(ast.NS, ast.DB) du, err := e.dbo.AllDU(ctx, ast.NS, ast.DB)
if err != nil { if err != nil {
return nil, err return nil, err
} }
sc, err := e.dbo.AllSC(ast.NS, ast.DB) sc, err := e.dbo.AllSC(ctx, ast.NS, ast.DB)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -133,27 +133,27 @@ func (e *executor) executeInfoDB(ctx context.Context, ast *sql.InfoStatement) (o
func (e *executor) executeInfoTB(ctx context.Context, ast *sql.InfoStatement) (out []interface{}, err error) { func (e *executor) executeInfoTB(ctx context.Context, ast *sql.InfoStatement) (out []interface{}, err error) {
ev, err := e.dbo.AllEV(ast.NS, ast.DB, ast.What.TB) ev, err := e.dbo.AllEV(ctx, ast.NS, ast.DB, ast.What.TB)
if err != nil { if err != nil {
return nil, err return nil, err
} }
fd, err := e.dbo.AllFD(ast.NS, ast.DB, ast.What.TB) fd, err := e.dbo.AllFD(ctx, ast.NS, ast.DB, ast.What.TB)
if err != nil { if err != nil {
return nil, err return nil, err
} }
ix, err := e.dbo.AllIX(ast.NS, ast.DB, ast.What.TB) ix, err := e.dbo.AllIX(ctx, ast.NS, ast.DB, ast.What.TB)
if err != nil { if err != nil {
return nil, err return nil, err
} }
lv, err := e.dbo.AllLV(ast.NS, ast.DB, ast.What.TB) lv, err := e.dbo.AllLV(ctx, ast.NS, ast.DB, ast.What.TB)
if err != nil { if err != nil {
return nil, err return nil, err
} }
ft, err := e.dbo.AllFT(ast.NS, ast.DB, ast.What.TB) ft, err := e.dbo.AllFT(ctx, ast.NS, ast.DB, ast.What.TB)
if err != nil { if err != nil {
return nil, err return nil, err
} }

10
db/iterator.go
View file

@ -388,7 +388,7 @@ func (i *iterator) processPerms(ctx context.Context, nsv, dbv, tbv string) {
// we need to fetch the table to ensure // we need to fetch the table to ensure
// that the table is not a view table. // that the table is not a view table.
tb, i.err = i.e.dbo.AddTB(nsv, dbv, tbv) tb, i.err = i.e.dbo.AddTB(ctx, nsv, dbv, tbv)
if i.err != nil { if i.err != nil {
close(i.stop) close(i.stop)
return return
@ -429,7 +429,7 @@ func (i *iterator) processPerms(ctx context.Context, nsv, dbv, tbv string) {
// otherwise, the scoped authentication // otherwise, the scoped authentication
// request can not do anything. // request can not do anything.
_, i.err = i.e.dbo.GetNS(nsv) _, i.err = i.e.dbo.GetNS(ctx, nsv)
if i.err != nil { if i.err != nil {
close(i.stop) close(i.stop)
return return
@ -439,7 +439,7 @@ func (i *iterator) processPerms(ctx context.Context, nsv, dbv, tbv string) {
// otherwise, the scoped authentication // otherwise, the scoped authentication
// request can not do anything. // request can not do anything.
_, i.err = i.e.dbo.GetDB(nsv, dbv) _, i.err = i.e.dbo.GetDB(ctx, nsv, dbv)
if i.err != nil { if i.err != nil {
close(i.stop) close(i.stop)
return return
@ -458,7 +458,7 @@ func (i *iterator) processPerms(ctx context.Context, nsv, dbv, tbv string) {
// otherwise, the scoped authentication // otherwise, the scoped authentication
// request can not do anything. // request can not do anything.
tb, i.err = i.e.dbo.GetTB(nsv, dbv, tbv) tb, i.err = i.e.dbo.GetTB(ctx, nsv, dbv, tbv)
if i.err != nil { if i.err != nil {
close(i.stop) close(i.stop)
return return
@ -569,7 +569,7 @@ func (i *iterator) processTable(ctx context.Context, key *keys.Table) {
return return
} }
vals, i.err = i.e.dbo.GetR(i.versn, min, max, 10000) vals, i.err = i.e.dbo.GetR(ctx, i.versn, min, max, 10000)
if i.err != nil { if i.err != nil {
close(i.stop) close(i.stop)
return return

2
db/lives.go
View file

@ -48,7 +48,7 @@ func (d *document) lives(ctx context.Context, when method) (err error) {
// specified for this table, and // specified for this table, and
// update values which have changed. // update values which have changed.
lvs, err := d.getLV() lvs, err := d.getLV(ctx)
if err != nil { if err != nil {
return err return err
} }

6
db/merge.go
View file

@ -98,7 +98,7 @@ func (d *document) defFld(ctx context.Context, met method) (err error) {
func (d *document) delFld(ctx context.Context, met method) (err error) { func (d *document) delFld(ctx context.Context, met method) (err error) {
tb, err := d.getTB() tb, err := d.getTB(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -109,7 +109,7 @@ func (d *document) delFld(ctx context.Context, met method) (err error) {
// Get the defined fields // Get the defined fields
fds, err := d.getFD() fds, err := d.getFD(ctx)
if err != nil { if err != nil {
return err return err
} }
@ -267,7 +267,7 @@ func (d *document) mrgSet(ctx context.Context, met method, expr *sql.DataExpress
func (d *document) mrgFld(ctx context.Context, met method) (err error) { func (d *document) mrgFld(ctx context.Context, met method) (err error) {
fds, err := d.getFD() fds, err := d.getFD(ctx)
if err != nil { if err != nil {
return err return err
} }

2
db/perms.go
View file

@ -37,7 +37,7 @@ func (d *document) perms(ctx context.Context, doc *data.Doc) (err error) {
// check if the permissions allow us // check if the permissions allow us
// to view each field. // to view each field.
fds, err := d.getFD() fds, err := d.getFD(ctx)
if err != nil { if err != nil {
return err return err
} }

34
db/remove.go
View file

@ -27,11 +27,11 @@ func (e *executor) executeRemoveNamespace(ctx context.Context, ast *sql.RemoveNa
// Remove the namespace definition // Remove the namespace definition
nkey := &keys.NS{KV: ast.KV, NS: ast.Name.ID} nkey := &keys.NS{KV: ast.KV, NS: ast.Name.ID}
_, err = e.dbo.Clr(nkey.Encode()) _, err = e.dbo.Clr(ctx, nkey.Encode())
// Remove the namespace resource data // Remove the namespace resource data
akey := &keys.Namespace{KV: ast.KV, NS: ast.Name.ID} akey := &keys.Namespace{KV: ast.KV, NS: ast.Name.ID}
_, err = e.dbo.ClrP(akey.Encode(), 0) _, err = e.dbo.ClrP(ctx, akey.Encode(), 0)
return return
@ -43,11 +43,11 @@ func (e *executor) executeRemoveDatabase(ctx context.Context, ast *sql.RemoveDat
// Remove the database definition // Remove the database definition
dkey := &keys.DB{KV: ast.KV, NS: ast.NS, DB: ast.Name.ID} dkey := &keys.DB{KV: ast.KV, NS: ast.NS, DB: ast.Name.ID}
_, err = e.dbo.Clr(dkey.Encode()) _, err = e.dbo.Clr(ctx, dkey.Encode())
// Remove the database resource data // Remove the database resource data
akey := &keys.Database{KV: ast.KV, NS: ast.NS, DB: ast.Name.ID} akey := &keys.Database{KV: ast.KV, NS: ast.NS, DB: ast.Name.ID}
_, err = e.dbo.ClrP(akey.Encode(), 0) _, err = e.dbo.ClrP(ctx, akey.Encode(), 0)
return return
@ -60,13 +60,13 @@ func (e *executor) executeRemoveLogin(ctx context.Context, ast *sql.RemoveLoginS
// Remove the login definition // Remove the login definition
ukey := &keys.NU{KV: ast.KV, NS: ast.NS, US: ast.User.ID} ukey := &keys.NU{KV: ast.KV, NS: ast.NS, US: ast.User.ID}
_, err = e.dbo.ClrP(ukey.Encode(), 0) _, err = e.dbo.ClrP(ctx, ukey.Encode(), 0)
case sql.DATABASE: case sql.DATABASE:
// Remove the login definition // Remove the login definition
ukey := &keys.DU{KV: ast.KV, NS: ast.NS, DB: ast.DB, US: ast.User.ID} ukey := &keys.DU{KV: ast.KV, NS: ast.NS, DB: ast.DB, US: ast.User.ID}
_, err = e.dbo.ClrP(ukey.Encode(), 0) _, err = e.dbo.ClrP(ctx, ukey.Encode(), 0)
} }
@ -81,13 +81,13 @@ func (e *executor) executeRemoveToken(ctx context.Context, ast *sql.RemoveTokenS
// Remove the token definition // Remove the token definition
tkey := &keys.NT{KV: ast.KV, NS: ast.NS, TK: ast.Name.ID} tkey := &keys.NT{KV: ast.KV, NS: ast.NS, TK: ast.Name.ID}
_, err = e.dbo.ClrP(tkey.Encode(), 0) _, err = e.dbo.ClrP(ctx, tkey.Encode(), 0)
case sql.DATABASE: case sql.DATABASE:
// Remove the token definition // Remove the token definition
tkey := &keys.DT{KV: ast.KV, NS: ast.NS, DB: ast.DB, TK: ast.Name.ID} tkey := &keys.DT{KV: ast.KV, NS: ast.NS, DB: ast.DB, TK: ast.Name.ID}
_, err = e.dbo.ClrP(tkey.Encode(), 0) _, err = e.dbo.ClrP(ctx, tkey.Encode(), 0)
} }
@ -99,7 +99,7 @@ func (e *executor) executeRemoveScope(ctx context.Context, ast *sql.RemoveScopeS
// Remove the scope definition // Remove the scope definition
skey := &keys.SC{KV: ast.KV, NS: ast.NS, DB: ast.DB, SC: ast.Name.ID} skey := &keys.SC{KV: ast.KV, NS: ast.NS, DB: ast.DB, SC: ast.Name.ID}
_, err = e.dbo.ClrP(skey.Encode(), 0) _, err = e.dbo.ClrP(ctx, skey.Encode(), 0)
return return
@ -113,7 +113,7 @@ func (e *executor) executeRemoveEvent(ctx context.Context, ast *sql.RemoveEventS
// Remove the event definition // Remove the event definition
ekey := &keys.EV{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, EV: ast.Name.ID} ekey := &keys.EV{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, EV: ast.Name.ID}
if _, err = e.dbo.ClrP(ekey.Encode(), 0); err != nil { if _, err = e.dbo.ClrP(ctx, ekey.Encode(), 0); err != nil {
return nil, err return nil, err
} }
@ -131,7 +131,7 @@ func (e *executor) executeRemoveField(ctx context.Context, ast *sql.RemoveFieldS
// Remove the field definition // Remove the field definition
fkey := &keys.FD{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, FD: ast.Name.ID} fkey := &keys.FD{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, FD: ast.Name.ID}
if _, err = e.dbo.ClrP(fkey.Encode(), 0); err != nil { if _, err = e.dbo.ClrP(ctx, fkey.Encode(), 0); err != nil {
return nil, err return nil, err
} }
@ -149,13 +149,13 @@ func (e *executor) executeRemoveIndex(ctx context.Context, ast *sql.RemoveIndexS
// Remove the index definition // Remove the index definition
ikey := &keys.IX{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, IX: ast.Name.ID} ikey := &keys.IX{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, IX: ast.Name.ID}
if _, err = e.dbo.ClrP(ikey.Encode(), 0); err != nil { if _, err = e.dbo.ClrP(ctx, ikey.Encode(), 0); err != nil {
return nil, err return nil, err
} }
// Remove the index resource data // Remove the index resource data
dkey := &keys.Index{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, IX: ast.Name.ID, FD: keys.Ignore} dkey := &keys.Index{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB, IX: ast.Name.ID, FD: keys.Ignore}
if _, err = e.dbo.ClrP(dkey.Encode(), 0); err != nil { if _, err = e.dbo.ClrP(ctx, dkey.Encode(), 0); err != nil {
return nil, err return nil, err
} }
@ -171,21 +171,21 @@ func (e *executor) executeRemoveTable(ctx context.Context, ast *sql.RemoveTableS
e.dbo.DelTB(ast.NS, ast.DB, TB.TB) e.dbo.DelTB(ast.NS, ast.DB, TB.TB)
tb, err := e.dbo.GetTB(ast.NS, ast.DB, TB.TB) tb, err := e.dbo.GetTB(ctx, ast.NS, ast.DB, TB.TB)
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Remove the table definition // Remove the table definition
tkey := &keys.TB{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB} tkey := &keys.TB{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB}
_, err = e.dbo.Clr(tkey.Encode()) _, err = e.dbo.Clr(ctx, tkey.Encode())
if err != nil { if err != nil {
return nil, err return nil, err
} }
// Remove the table resource data // Remove the table resource data
dkey := &keys.Table{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB} dkey := &keys.Table{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: TB.TB}
_, err = e.dbo.ClrP(dkey.Encode(), 0) _, err = e.dbo.ClrP(ctx, dkey.Encode(), 0)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -196,7 +196,7 @@ func (e *executor) executeRemoveTable(ctx context.Context, ast *sql.RemoveTableS
// Remove the foreign table definition // Remove the foreign table definition
tkey := &keys.FT{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: FT.TB, FT: TB.TB} tkey := &keys.FT{KV: ast.KV, NS: ast.NS, DB: ast.DB, TB: FT.TB, FT: TB.TB}
if _, err = e.dbo.ClrP(tkey.Encode(), 0); err != nil { if _, err = e.dbo.ClrP(ctx, tkey.Encode(), 0); err != nil {
return nil, err return nil, err
} }

22
db/socket.go
View file

@ -157,7 +157,7 @@ func (s *socket) check(e *executor, ctx context.Context, ns, db, tb string) (err
// otherwise, the scoped authentication // otherwise, the scoped authentication
// request can not do anything. // request can not do anything.
_, err = e.dbo.GetNS(ns) _, err = e.dbo.GetNS(ctx, ns)
if err != nil { if err != nil {
return err return err
} }
@ -166,7 +166,7 @@ func (s *socket) check(e *executor, ctx context.Context, ns, db, tb string) (err
// otherwise, the scoped authentication // otherwise, the scoped authentication
// request can not do anything. // request can not do anything.
_, err = e.dbo.GetDB(ns, db) _, err = e.dbo.GetDB(ctx, ns, db)
if err != nil { if err != nil {
return err return err
} }
@ -175,7 +175,7 @@ func (s *socket) check(e *executor, ctx context.Context, ns, db, tb string) (err
// otherwise, the scoped authentication // otherwise, the scoped authentication
// request can not do anything. // request can not do anything.
tbv, err = e.dbo.GetTB(ns, db, tb) tbv, err = e.dbo.GetTB(ctx, ns, db, tb)
if err != nil { if err != nil {
return err return err
} }
@ -222,7 +222,9 @@ func (s *socket) deregister(id string) {
sockets.Delete(id) sockets.Delete(id)
txn, _ := db.Begin(context.Background(), true) ctx := context.Background()
txn, _ := db.Begin(ctx, true)
defer txn.Commit() defer txn.Commit()
@ -235,12 +237,12 @@ func (s *socket) deregister(id string) {
case *sql.Table: case *sql.Table:
key := &keys.LV{KV: stm.KV, NS: stm.NS, DB: stm.DB, TB: what.TB, LV: id} key := &keys.LV{KV: stm.KV, NS: stm.NS, DB: stm.DB, TB: what.TB, LV: id}
txn.Clr(key.Encode()) txn.Clr(ctx, key.Encode())
case *sql.Ident: case *sql.Ident:
key := &keys.LV{KV: stm.KV, NS: stm.NS, DB: stm.DB, TB: what.ID, LV: id} key := &keys.LV{KV: stm.KV, NS: stm.NS, DB: stm.DB, TB: what.ID, LV: id}
txn.Clr(key.Encode()) txn.Clr(ctx, key.Encode())
} }
@ -291,7 +293,7 @@ func (s *socket) executeLive(e *executor, ctx context.Context, stm *sql.LiveStat
} }
key := &keys.LV{KV: stm.KV, NS: stm.NS, DB: stm.DB, TB: what.TB, LV: stm.ID} key := &keys.LV{KV: stm.KV, NS: stm.NS, DB: stm.DB, TB: what.TB, LV: stm.ID}
if _, err = e.dbo.Put(0, key.Encode(), stm.Encode()); err != nil { if _, err = e.dbo.Put(ctx, 0, key.Encode(), stm.Encode()); err != nil {
return nil, err return nil, err
} }
@ -302,7 +304,7 @@ func (s *socket) executeLive(e *executor, ctx context.Context, stm *sql.LiveStat
} }
key := &keys.LV{KV: stm.KV, NS: stm.NS, DB: stm.DB, TB: what.ID, LV: stm.ID} key := &keys.LV{KV: stm.KV, NS: stm.NS, DB: stm.DB, TB: what.ID, LV: stm.ID}
if _, err = e.dbo.Put(0, key.Encode(), stm.Encode()); err != nil { if _, err = e.dbo.Put(ctx, 0, key.Encode(), stm.Encode()); err != nil {
return nil, err return nil, err
} }
@ -352,11 +354,11 @@ func (s *socket) executeKill(e *executor, ctx context.Context, stm *sql.KillStat
case *sql.Table: case *sql.Table:
key := &keys.LV{KV: qry.KV, NS: qry.NS, DB: qry.DB, TB: what.TB, LV: qry.ID} key := &keys.LV{KV: qry.KV, NS: qry.NS, DB: qry.DB, TB: what.TB, LV: qry.ID}
_, err = e.dbo.Clr(key.Encode()) _, err = e.dbo.Clr(ctx, key.Encode())
case *sql.Ident: case *sql.Ident:
key := &keys.LV{KV: qry.KV, NS: qry.NS, DB: qry.DB, TB: what.ID, LV: qry.ID} key := &keys.LV{KV: qry.KV, NS: qry.NS, DB: qry.DB, TB: what.ID, LV: qry.ID}
_, err = e.dbo.Clr(key.Encode()) _, err = e.dbo.Clr(ctx, key.Encode())
} }

2
db/table.go
View file

@ -47,7 +47,7 @@ func (d *document) table(ctx context.Context, when method) (err error) {
// specified for this table, and // specified for this table, and
// update values which have changed. // update values which have changed.
fts, err := d.getFT() fts, err := d.getFT(ctx)
if err != nil { if err != nil {
return err return err
} }

86
kvs/mysql/tx.go
View file

@ -18,6 +18,8 @@ import (
"math" "math"
"sync" "sync"
"context"
"database/sql" "database/sql"
"github.com/abcum/surreal/cnf" "github.com/abcum/surreal/cnf"
@ -141,7 +143,7 @@ func (tx *TX) Commit() error {
return tx.pntr.Commit() return tx.pntr.Commit()
} }
func (tx *TX) Clr(key []byte) (kvs.KV, error) { func (tx *TX) Clr(ctx context.Context, key []byte) (kvs.KV, error) {
var err error var err error
var res *sql.Rows var res *sql.Rows
@ -150,16 +152,16 @@ func (tx *TX) Clr(key []byte) (kvs.KV, error) {
defer tx.lock.Unlock() defer tx.lock.Unlock()
if tx.stmt.clr == nil { if tx.stmt.clr == nil {
tx.stmt.clr, _ = tx.pntr.Prepare(sqlClr) tx.stmt.clr, _ = tx.pntr.PrepareContext(ctx, sqlClr)
} }
res, err = tx.stmt.clr.Query(key) res, err = tx.stmt.clr.QueryContext(ctx, key)
return one(res, err) return one(res, err)
} }
func (tx *TX) ClrP(key []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) ClrP(ctx context.Context, key []byte, max uint64) ([]kvs.KV, error) {
var err error var err error
var res *sql.Rows var res *sql.Rows
@ -172,16 +174,16 @@ func (tx *TX) ClrP(key []byte, max uint64) ([]kvs.KV, error) {
defer tx.lock.Unlock() defer tx.lock.Unlock()
if tx.stmt.clrP == nil { if tx.stmt.clrP == nil {
tx.stmt.clrP, _ = tx.pntr.Prepare(sqlClrP) tx.stmt.clrP, _ = tx.pntr.PrepareContext(ctx, sqlClrP)
} }
res, err = tx.stmt.clrP.Query(key, max) res, err = tx.stmt.clrP.QueryContext(ctx, key, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) ClrR(beg []byte, end []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) ClrR(ctx context.Context, beg []byte, end []byte, max uint64) ([]kvs.KV, error) {
var err error var err error
var res *sql.Rows var res *sql.Rows
@ -194,16 +196,16 @@ func (tx *TX) ClrR(beg []byte, end []byte, max uint64) ([]kvs.KV, error) {
defer tx.lock.Unlock() defer tx.lock.Unlock()
if tx.stmt.clrR == nil { if tx.stmt.clrR == nil {
tx.stmt.clrR, _ = tx.pntr.Prepare(sqlClrR) tx.stmt.clrR, _ = tx.pntr.PrepareContext(ctx, sqlClrR)
} }
res, err = tx.stmt.clrR.Query(beg, end, max) res, err = tx.stmt.clrR.QueryContext(ctx, beg, end, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) Get(ver int64, key []byte) (kvs.KV, error) { func (tx *TX) Get(ctx context.Context, ver int64, key []byte) (kvs.KV, error) {
var err error var err error
var res *sql.Rows var res *sql.Rows
@ -212,16 +214,16 @@ func (tx *TX) Get(ver int64, key []byte) (kvs.KV, error) {
defer tx.lock.Unlock() defer tx.lock.Unlock()
if tx.stmt.get == nil { if tx.stmt.get == nil {
tx.stmt.get, _ = tx.pntr.Prepare(sqlGet) tx.stmt.get, _ = tx.pntr.PrepareContext(ctx, sqlGet)
} }
res, err = tx.stmt.get.Query(ver, key) res, err = tx.stmt.get.QueryContext(ctx, ver, key)
return one(res, err) return one(res, err)
} }
func (tx *TX) GetP(ver int64, key []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) GetP(ctx context.Context, ver int64, key []byte, max uint64) ([]kvs.KV, error) {
var err error var err error
var res *sql.Rows var res *sql.Rows
@ -234,16 +236,16 @@ func (tx *TX) GetP(ver int64, key []byte, max uint64) ([]kvs.KV, error) {
defer tx.lock.Unlock() defer tx.lock.Unlock()
if tx.stmt.getP == nil { if tx.stmt.getP == nil {
tx.stmt.getP, _ = tx.pntr.Prepare(sqlGetP) tx.stmt.getP, _ = tx.pntr.PrepareContext(ctx, sqlGetP)
} }
res, err = tx.stmt.getP.Query(ver, key, max) res, err = tx.stmt.getP.QueryContext(ctx, ver, key, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) GetR(ver int64, beg []byte, end []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) GetR(ctx context.Context, ver int64, beg []byte, end []byte, max uint64) ([]kvs.KV, error) {
var err error var err error
var res *sql.Rows var res *sql.Rows
@ -256,16 +258,16 @@ func (tx *TX) GetR(ver int64, beg []byte, end []byte, max uint64) ([]kvs.KV, err
defer tx.lock.Unlock() defer tx.lock.Unlock()
if tx.stmt.getR == nil { if tx.stmt.getR == nil {
tx.stmt.getR, _ = tx.pntr.Prepare(sqlGetR) tx.stmt.getR, _ = tx.pntr.PrepareContext(ctx, sqlGetR)
} }
res, err = tx.stmt.getR.Query(ver, beg, end, max) res, err = tx.stmt.getR.QueryContext(ctx, ver, beg, end, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) Del(ver int64, key []byte) (kvs.KV, error) { func (tx *TX) Del(ctx context.Context, ver int64, key []byte) (kvs.KV, error) {
var err error var err error
var res *sql.Rows var res *sql.Rows
@ -274,16 +276,16 @@ func (tx *TX) Del(ver int64, key []byte) (kvs.KV, error) {
defer tx.lock.Unlock() defer tx.lock.Unlock()
if tx.stmt.del == nil { if tx.stmt.del == nil {
tx.stmt.del, _ = tx.pntr.Prepare(sqlDel) tx.stmt.del, _ = tx.pntr.PrepareContext(ctx, sqlDel)
} }
res, err = tx.stmt.del.Query(ver, key) res, err = tx.stmt.del.QueryContext(ctx, ver, key)
return one(res, err) return one(res, err)
} }
func (tx *TX) DelC(ver int64, key []byte, exp []byte) (kvs.KV, error) { func (tx *TX) DelC(ctx context.Context, ver int64, key []byte, exp []byte) (kvs.KV, error) {
var err error var err error
var now kvs.KV var now kvs.KV
@ -295,10 +297,10 @@ func (tx *TX) DelC(ver int64, key []byte, exp []byte) (kvs.KV, error) {
// Get the item at the key // Get the item at the key
if tx.stmt.get == nil { if tx.stmt.get == nil {
tx.stmt.get, _ = tx.pntr.Prepare(sqlGet) tx.stmt.get, _ = tx.pntr.PrepareContext(ctx, sqlGet)
} }
res, err = tx.stmt.get.Query(ver, key) res, err = tx.stmt.get.QueryContext(ctx, ver, key)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -317,16 +319,16 @@ func (tx *TX) DelC(ver int64, key []byte, exp []byte) (kvs.KV, error) {
// If they match then delete // If they match then delete
if tx.stmt.del == nil { if tx.stmt.del == nil {
tx.stmt.del, _ = tx.pntr.Prepare(sqlDel) tx.stmt.del, _ = tx.pntr.PrepareContext(ctx, sqlDel)
} }
res, err = tx.stmt.del.Query(ver, key) res, err = tx.stmt.del.QueryContext(ctx, ver, key)
return one(res, err) return one(res, err)
} }
func (tx *TX) DelP(ver int64, key []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) DelP(ctx context.Context, ver int64, key []byte, max uint64) ([]kvs.KV, error) {
var err error var err error
var res *sql.Rows var res *sql.Rows
@ -339,16 +341,16 @@ func (tx *TX) DelP(ver int64, key []byte, max uint64) ([]kvs.KV, error) {
defer tx.lock.Unlock() defer tx.lock.Unlock()
if tx.stmt.delP == nil { if tx.stmt.delP == nil {
tx.stmt.delP, _ = tx.pntr.Prepare(sqlDelP) tx.stmt.delP, _ = tx.pntr.PrepareContext(ctx, sqlDelP)
} }
res, err = tx.stmt.delP.Query(ver, key, max) res, err = tx.stmt.delP.QueryContext(ctx, ver, key, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) DelR(ver int64, beg []byte, end []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) DelR(ctx context.Context, ver int64, beg []byte, end []byte, max uint64) ([]kvs.KV, error) {
var err error var err error
var res *sql.Rows var res *sql.Rows
@ -361,16 +363,16 @@ func (tx *TX) DelR(ver int64, beg []byte, end []byte, max uint64) ([]kvs.KV, err
defer tx.lock.Unlock() defer tx.lock.Unlock()
if tx.stmt.delR == nil { if tx.stmt.delR == nil {
tx.stmt.delR, _ = tx.pntr.Prepare(sqlDelR) tx.stmt.delR, _ = tx.pntr.PrepareContext(ctx, sqlDelR)
} }
res, err = tx.stmt.delR.Query(ver, beg, end, max) res, err = tx.stmt.delR.QueryContext(ctx, ver, beg, end, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) Put(ver int64, key []byte, val []byte) (kvs.KV, error) { func (tx *TX) Put(ctx context.Context, ver int64, key []byte, val []byte) (kvs.KV, error) {
var err error var err error
var res *sql.Rows var res *sql.Rows
@ -384,16 +386,16 @@ func (tx *TX) Put(ver int64, key []byte, val []byte) (kvs.KV, error) {
defer tx.lock.Unlock() defer tx.lock.Unlock()
if tx.stmt.put == nil { if tx.stmt.put == nil {
tx.stmt.put, _ = tx.pntr.Prepare(sqlPut) tx.stmt.put, _ = tx.pntr.PrepareContext(ctx, sqlPut)
} }
res, err = tx.stmt.put.Query(ver, key, val, val) res, err = tx.stmt.put.QueryContext(ctx, ver, key, val, val)
return one(res, err) return one(res, err)
} }
func (tx *TX) PutC(ver int64, key []byte, val []byte, exp []byte) (kvs.KV, error) { func (tx *TX) PutC(ctx context.Context, ver int64, key []byte, val []byte, exp []byte) (kvs.KV, error) {
var err error var err error
var now kvs.KV var now kvs.KV
@ -409,10 +411,10 @@ func (tx *TX) PutC(ver int64, key []byte, val []byte, exp []byte) (kvs.KV, error
case nil: case nil:
if tx.stmt.putN == nil { if tx.stmt.putN == nil {
tx.stmt.putN, _ = tx.pntr.Prepare(sqlPutN) tx.stmt.putN, _ = tx.pntr.PrepareContext(ctx, sqlPutN)
} }
res, err = tx.stmt.putN.Query(ver, key, val) res, err = tx.stmt.putN.QueryContext(ctx, ver, key, val)
return one(res, err) return one(res, err)
@ -421,10 +423,10 @@ func (tx *TX) PutC(ver int64, key []byte, val []byte, exp []byte) (kvs.KV, error
// Get the item at the key // Get the item at the key
if tx.stmt.get == nil { if tx.stmt.get == nil {
tx.stmt.get, _ = tx.pntr.Prepare(sqlGet) tx.stmt.get, _ = tx.pntr.PrepareContext(ctx, sqlGet)
} }
res, err = tx.stmt.get.Query(ver, key) res, err = tx.stmt.get.QueryContext(ctx, ver, key)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -443,10 +445,10 @@ func (tx *TX) PutC(ver int64, key []byte, val []byte, exp []byte) (kvs.KV, error
// If they match then delete // If they match then delete
if tx.stmt.del == nil { if tx.stmt.del == nil {
tx.stmt.put, _ = tx.pntr.Prepare(sqlPut) tx.stmt.put, _ = tx.pntr.PrepareContext(ctx, sqlPut)
} }
res, err = tx.stmt.put.Query(ver, key, val, val) res, err = tx.stmt.put.QueryContext(ctx, ver, key, val, val)
return one(res, err) return one(res, err)

26
kvs/rixxdb/tx.go
View file

@ -15,6 +15,8 @@
package rixxdb package rixxdb
import ( import (
"context"
"github.com/abcum/rixxdb" "github.com/abcum/rixxdb"
"github.com/abcum/surreal/kvs" "github.com/abcum/surreal/kvs"
) )
@ -71,62 +73,62 @@ func (tx *TX) Commit() error {
return tx.pntr.Commit() return tx.pntr.Commit()
} }
func (tx *TX) Clr(key []byte) (kvs.KV, error) { func (tx *TX) Clr(ctx context.Context, key []byte) (kvs.KV, error) {
res, err := tx.pntr.Clr(key) res, err := tx.pntr.Clr(key)
return one(res, err) return one(res, err)
} }
func (tx *TX) ClrP(key []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) ClrP(ctx context.Context, key []byte, max uint64) ([]kvs.KV, error) {
res, err := tx.pntr.ClrP(key, max) res, err := tx.pntr.ClrP(key, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) ClrR(beg []byte, end []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) ClrR(ctx context.Context, beg []byte, end []byte, max uint64) ([]kvs.KV, error) {
res, err := tx.pntr.ClrR(beg, end, max) res, err := tx.pntr.ClrR(beg, end, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) Get(ver int64, key []byte) (kvs.KV, error) { func (tx *TX) Get(ctx context.Context, ver int64, key []byte) (kvs.KV, error) {
res, err := tx.pntr.Get(uint64(ver), key) res, err := tx.pntr.Get(uint64(ver), key)
return one(res, err) return one(res, err)
} }
func (tx *TX) GetP(ver int64, key []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) GetP(ctx context.Context, ver int64, key []byte, max uint64) ([]kvs.KV, error) {
res, err := tx.pntr.GetP(uint64(ver), key, max) res, err := tx.pntr.GetP(uint64(ver), key, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) GetR(ver int64, beg []byte, end []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) GetR(ctx context.Context, ver int64, beg []byte, end []byte, max uint64) ([]kvs.KV, error) {
res, err := tx.pntr.GetR(uint64(ver), beg, end, max) res, err := tx.pntr.GetR(uint64(ver), beg, end, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) Del(ver int64, key []byte) (kvs.KV, error) { func (tx *TX) Del(ctx context.Context, ver int64, key []byte) (kvs.KV, error) {
res, err := tx.pntr.Del(uint64(ver), key) res, err := tx.pntr.Del(uint64(ver), key)
return one(res, err) return one(res, err)
} }
func (tx *TX) DelC(ver int64, key []byte, exp []byte) (kvs.KV, error) { func (tx *TX) DelC(ctx context.Context, ver int64, key []byte, exp []byte) (kvs.KV, error) {
res, err := tx.pntr.DelC(uint64(ver), key, exp) res, err := tx.pntr.DelC(uint64(ver), key, exp)
return one(res, err) return one(res, err)
} }
func (tx *TX) DelP(ver int64, key []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) DelP(ctx context.Context, ver int64, key []byte, max uint64) ([]kvs.KV, error) {
res, err := tx.pntr.DelP(uint64(ver), key, max) res, err := tx.pntr.DelP(uint64(ver), key, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) DelR(ver int64, beg []byte, end []byte, max uint64) ([]kvs.KV, error) { func (tx *TX) DelR(ctx context.Context, ver int64, beg []byte, end []byte, max uint64) ([]kvs.KV, error) {
res, err := tx.pntr.DelR(uint64(ver), beg, end, max) res, err := tx.pntr.DelR(uint64(ver), beg, end, max)
return many(res, err) return many(res, err)
} }
func (tx *TX) Put(ver int64, key []byte, val []byte) (kvs.KV, error) { func (tx *TX) Put(ctx context.Context, ver int64, key []byte, val []byte) (kvs.KV, error) {
res, err := tx.pntr.Put(uint64(ver), key, val) res, err := tx.pntr.Put(uint64(ver), key, val)
return one(res, err) return one(res, err)
} }
func (tx *TX) PutC(ver int64, key []byte, val []byte, exp []byte) (kvs.KV, error) { func (tx *TX) PutC(ctx context.Context, ver int64, key []byte, val []byte, exp []byte) (kvs.KV, error) {
res, err := tx.pntr.PutC(uint64(ver), key, val, exp) res, err := tx.pntr.PutC(uint64(ver), key, val, exp)
return one(res, err) return one(res, err)
} }

26
kvs/tx.go
View file

@ -14,25 +14,27 @@
package kvs package kvs
import "context"
// TX represents a database transaction // TX represents a database transaction
type TX interface { type TX interface {
Closed() bool Closed() bool
Cancel() error Cancel() error
Commit() error Commit() error
Clr([]byte) (KV, error) Clr(context.Context, []byte) (KV, error)
ClrP([]byte, uint64) ([]KV, error) ClrP(context.Context, []byte, uint64) ([]KV, error)
ClrR([]byte, []byte, uint64) ([]KV, error) ClrR(context.Context, []byte, []byte, uint64) ([]KV, error)
Get(int64, []byte) (KV, error) Get(context.Context, int64, []byte) (KV, error)
GetP(int64, []byte, uint64) ([]KV, error) GetP(context.Context, int64, []byte, uint64) ([]KV, error)
GetR(int64, []byte, []byte, uint64) ([]KV, error) GetR(context.Context, int64, []byte, []byte, uint64) ([]KV, error)
Del(int64, []byte) (KV, error) Del(context.Context, int64, []byte) (KV, error)
DelC(int64, []byte, []byte) (KV, error) DelC(context.Context, int64, []byte, []byte) (KV, error)
DelP(int64, []byte, uint64) ([]KV, error) DelP(context.Context, int64, []byte, uint64) ([]KV, error)
DelR(int64, []byte, []byte, uint64) ([]KV, error) DelR(context.Context, int64, []byte, []byte, uint64) ([]KV, error)
Put(int64, []byte, []byte) (KV, error) Put(context.Context, int64, []byte, []byte) (KV, error)
PutC(int64, []byte, []byte, []byte) (KV, error) PutC(context.Context, int64, []byte, []byte, []byte) (KV, error)
} }

136
mem/mem.go
View file

@ -17,6 +17,8 @@ package mem
import ( import (
"sync" "sync"
"context"
"github.com/abcum/surreal/cnf" "github.com/abcum/surreal/cnf"
"github.com/abcum/surreal/kvs" "github.com/abcum/surreal/kvs"
"github.com/abcum/surreal/sql" "github.com/abcum/surreal/sql"
@ -72,7 +74,7 @@ func (c *Cache) del(key keys.Key) {
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllNS() (out []*sql.DefineNamespaceStatement, err error) { func (c *Cache) AllNS(ctx context.Context) (out []*sql.DefineNamespaceStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
@ -85,7 +87,7 @@ func (c *Cache) AllNS() (out []*sql.DefineNamespaceStatement, err error) {
return out.([]*sql.DefineNamespaceStatement), nil return out.([]*sql.DefineNamespaceStatement), nil
} }
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -101,7 +103,7 @@ func (c *Cache) AllNS() (out []*sql.DefineNamespaceStatement, err error) {
} }
func (c *Cache) GetNS(ns string) (val *sql.DefineNamespaceStatement, err error) { func (c *Cache) GetNS(ctx context.Context, ns string) (val *sql.DefineNamespaceStatement, err error) {
var kv kvs.KV var kv kvs.KV
@ -114,7 +116,7 @@ func (c *Cache) GetNS(ns string) (val *sql.DefineNamespaceStatement, err error)
return out.(*sql.DefineNamespaceStatement), nil return out.(*sql.DefineNamespaceStatement), nil
} }
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -131,7 +133,7 @@ func (c *Cache) GetNS(ns string) (val *sql.DefineNamespaceStatement, err error)
} }
func (c *Cache) AddNS(ns string) (val *sql.DefineNamespaceStatement, err error) { func (c *Cache) AddNS(ctx context.Context, ns string) (val *sql.DefineNamespaceStatement, err error) {
var kv kvs.KV var kv kvs.KV
@ -144,7 +146,7 @@ func (c *Cache) AddNS(ns string) (val *sql.DefineNamespaceStatement, err error)
return out.(*sql.DefineNamespaceStatement), nil return out.(*sql.DefineNamespaceStatement), nil
} }
if kv, _ = c.TX.Get(0, key.Encode()); kv.Exi() { if kv, _ = c.TX.Get(ctx, 0, key.Encode()); kv.Exi() {
val = &sql.DefineNamespaceStatement{} val = &sql.DefineNamespaceStatement{}
val.Decode(kv.Val()) val.Decode(kv.Val())
c.put(key, val) c.put(key, val)
@ -152,7 +154,7 @@ func (c *Cache) AddNS(ns string) (val *sql.DefineNamespaceStatement, err error)
} }
val = &sql.DefineNamespaceStatement{Name: sql.NewIdent(ns)} val = &sql.DefineNamespaceStatement{Name: sql.NewIdent(ns)}
c.TX.PutC(0, key.Encode(), val.Encode(), nil) c.TX.PutC(ctx, 0, key.Encode(), val.Encode(), nil)
c.put(key, val) c.put(key, val)
@ -170,12 +172,12 @@ func (c *Cache) DelNS(ns string) {
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllNT(ns string) (out []*sql.DefineTokenStatement, err error) { func (c *Cache) AllNT(ctx context.Context, ns string) (out []*sql.DefineTokenStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
key := &keys.NT{KV: cnf.Settings.DB.Base, NS: ns, TK: keys.Ignore} key := &keys.NT{KV: cnf.Settings.DB.Base, NS: ns, TK: keys.Ignore}
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -189,12 +191,12 @@ func (c *Cache) AllNT(ns string) (out []*sql.DefineTokenStatement, err error) {
} }
func (c *Cache) GetNT(ns, tk string) (val *sql.DefineTokenStatement, err error) { func (c *Cache) GetNT(ctx context.Context, ns, tk string) (val *sql.DefineTokenStatement, err error) {
var kv kvs.KV var kv kvs.KV
key := &keys.NT{KV: cnf.Settings.DB.Base, NS: ns, TK: tk} key := &keys.NT{KV: cnf.Settings.DB.Base, NS: ns, TK: tk}
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -211,12 +213,12 @@ func (c *Cache) GetNT(ns, tk string) (val *sql.DefineTokenStatement, err error)
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllNU(ns string) (out []*sql.DefineLoginStatement, err error) { func (c *Cache) AllNU(ctx context.Context, ns string) (out []*sql.DefineLoginStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
key := &keys.NU{KV: cnf.Settings.DB.Base, NS: ns, US: keys.Ignore} key := &keys.NU{KV: cnf.Settings.DB.Base, NS: ns, US: keys.Ignore}
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -230,12 +232,12 @@ func (c *Cache) AllNU(ns string) (out []*sql.DefineLoginStatement, err error) {
} }
func (c *Cache) GetNU(ns, us string) (val *sql.DefineLoginStatement, err error) { func (c *Cache) GetNU(ctx context.Context, ns, us string) (val *sql.DefineLoginStatement, err error) {
var kv kvs.KV var kv kvs.KV
key := &keys.NU{KV: cnf.Settings.DB.Base, NS: ns, US: us} key := &keys.NU{KV: cnf.Settings.DB.Base, NS: ns, US: us}
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -252,7 +254,7 @@ func (c *Cache) GetNU(ns, us string) (val *sql.DefineLoginStatement, err error)
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllDB(ns string) (out []*sql.DefineDatabaseStatement, err error) { func (c *Cache) AllDB(ctx context.Context, ns string) (out []*sql.DefineDatabaseStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
@ -265,7 +267,7 @@ func (c *Cache) AllDB(ns string) (out []*sql.DefineDatabaseStatement, err error)
return out.([]*sql.DefineDatabaseStatement), nil return out.([]*sql.DefineDatabaseStatement), nil
} }
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -281,7 +283,7 @@ func (c *Cache) AllDB(ns string) (out []*sql.DefineDatabaseStatement, err error)
} }
func (c *Cache) GetDB(ns, db string) (val *sql.DefineDatabaseStatement, err error) { func (c *Cache) GetDB(ctx context.Context, ns, db string) (val *sql.DefineDatabaseStatement, err error) {
var kv kvs.KV var kv kvs.KV
@ -294,7 +296,7 @@ func (c *Cache) GetDB(ns, db string) (val *sql.DefineDatabaseStatement, err erro
return out.(*sql.DefineDatabaseStatement), nil return out.(*sql.DefineDatabaseStatement), nil
} }
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -311,9 +313,9 @@ func (c *Cache) GetDB(ns, db string) (val *sql.DefineDatabaseStatement, err erro
} }
func (c *Cache) AddDB(ns, db string) (val *sql.DefineDatabaseStatement, err error) { func (c *Cache) AddDB(ctx context.Context, ns, db string) (val *sql.DefineDatabaseStatement, err error) {
if _, err = c.AddNS(ns); err != nil { if _, err = c.AddNS(ctx, ns); err != nil {
return return
} }
@ -328,7 +330,7 @@ func (c *Cache) AddDB(ns, db string) (val *sql.DefineDatabaseStatement, err erro
return out.(*sql.DefineDatabaseStatement), nil return out.(*sql.DefineDatabaseStatement), nil
} }
if kv, _ = c.TX.Get(0, key.Encode()); kv.Exi() { if kv, _ = c.TX.Get(ctx, 0, key.Encode()); kv.Exi() {
val = &sql.DefineDatabaseStatement{} val = &sql.DefineDatabaseStatement{}
val.Decode(kv.Val()) val.Decode(kv.Val())
c.put(key, val) c.put(key, val)
@ -336,7 +338,7 @@ func (c *Cache) AddDB(ns, db string) (val *sql.DefineDatabaseStatement, err erro
} }
val = &sql.DefineDatabaseStatement{Name: sql.NewIdent(db)} val = &sql.DefineDatabaseStatement{Name: sql.NewIdent(db)}
c.TX.PutC(0, key.Encode(), val.Encode(), nil) c.TX.PutC(ctx, 0, key.Encode(), val.Encode(), nil)
c.put(key, val) c.put(key, val)
@ -354,12 +356,12 @@ func (c *Cache) DelDB(ns, db string) {
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllDT(ns, db string) (out []*sql.DefineTokenStatement, err error) { func (c *Cache) AllDT(ctx context.Context, ns, db string) (out []*sql.DefineTokenStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
key := &keys.DT{KV: cnf.Settings.DB.Base, NS: ns, DB: db, TK: keys.Ignore} key := &keys.DT{KV: cnf.Settings.DB.Base, NS: ns, DB: db, TK: keys.Ignore}
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -373,12 +375,12 @@ func (c *Cache) AllDT(ns, db string) (out []*sql.DefineTokenStatement, err error
} }
func (c *Cache) GetDT(ns, db, tk string) (val *sql.DefineTokenStatement, err error) { func (c *Cache) GetDT(ctx context.Context, ns, db, tk string) (val *sql.DefineTokenStatement, err error) {
var kv kvs.KV var kv kvs.KV
key := &keys.DT{KV: cnf.Settings.DB.Base, NS: ns, DB: db, TK: tk} key := &keys.DT{KV: cnf.Settings.DB.Base, NS: ns, DB: db, TK: tk}
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -395,12 +397,12 @@ func (c *Cache) GetDT(ns, db, tk string) (val *sql.DefineTokenStatement, err err
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllDU(ns, db string) (out []*sql.DefineLoginStatement, err error) { func (c *Cache) AllDU(ctx context.Context, ns, db string) (out []*sql.DefineLoginStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
key := &keys.DU{KV: cnf.Settings.DB.Base, NS: ns, DB: db, US: keys.Ignore} key := &keys.DU{KV: cnf.Settings.DB.Base, NS: ns, DB: db, US: keys.Ignore}
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -414,12 +416,12 @@ func (c *Cache) AllDU(ns, db string) (out []*sql.DefineLoginStatement, err error
} }
func (c *Cache) GetDU(ns, db, us string) (val *sql.DefineLoginStatement, err error) { func (c *Cache) GetDU(ctx context.Context, ns, db, us string) (val *sql.DefineLoginStatement, err error) {
var kv kvs.KV var kv kvs.KV
key := &keys.DU{KV: cnf.Settings.DB.Base, NS: ns, DB: db, US: us} key := &keys.DU{KV: cnf.Settings.DB.Base, NS: ns, DB: db, US: us}
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -436,12 +438,12 @@ func (c *Cache) GetDU(ns, db, us string) (val *sql.DefineLoginStatement, err err
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllSC(ns, db string) (out []*sql.DefineScopeStatement, err error) { func (c *Cache) AllSC(ctx context.Context, ns, db string) (out []*sql.DefineScopeStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
key := &keys.SC{KV: cnf.Settings.DB.Base, NS: ns, DB: db, SC: keys.Ignore} key := &keys.SC{KV: cnf.Settings.DB.Base, NS: ns, DB: db, SC: keys.Ignore}
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -455,12 +457,12 @@ func (c *Cache) AllSC(ns, db string) (out []*sql.DefineScopeStatement, err error
} }
func (c *Cache) GetSC(ns, db, sc string) (val *sql.DefineScopeStatement, err error) { func (c *Cache) GetSC(ctx context.Context, ns, db, sc string) (val *sql.DefineScopeStatement, err error) {
var kv kvs.KV var kv kvs.KV
key := &keys.SC{KV: cnf.Settings.DB.Base, NS: ns, DB: db, SC: sc} key := &keys.SC{KV: cnf.Settings.DB.Base, NS: ns, DB: db, SC: sc}
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -477,12 +479,12 @@ func (c *Cache) GetSC(ns, db, sc string) (val *sql.DefineScopeStatement, err err
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllST(ns, db, sc string) (out []*sql.DefineTokenStatement, err error) { func (c *Cache) AllST(ctx context.Context, ns, db, sc string) (out []*sql.DefineTokenStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
key := &keys.ST{KV: cnf.Settings.DB.Base, NS: ns, DB: db, SC: sc, TK: keys.Ignore} key := &keys.ST{KV: cnf.Settings.DB.Base, NS: ns, DB: db, SC: sc, TK: keys.Ignore}
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -496,12 +498,12 @@ func (c *Cache) AllST(ns, db, sc string) (out []*sql.DefineTokenStatement, err e
} }
func (c *Cache) GetST(ns, db, sc, tk string) (val *sql.DefineTokenStatement, err error) { func (c *Cache) GetST(ctx context.Context, ns, db, sc, tk string) (val *sql.DefineTokenStatement, err error) {
var kv kvs.KV var kv kvs.KV
key := &keys.ST{KV: cnf.Settings.DB.Base, NS: ns, DB: db, SC: sc, TK: tk} key := &keys.ST{KV: cnf.Settings.DB.Base, NS: ns, DB: db, SC: sc, TK: tk}
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -518,7 +520,7 @@ func (c *Cache) GetST(ns, db, sc, tk string) (val *sql.DefineTokenStatement, err
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllTB(ns, db string) (out []*sql.DefineTableStatement, err error) { func (c *Cache) AllTB(ctx context.Context, ns, db string) (out []*sql.DefineTableStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
@ -531,7 +533,7 @@ func (c *Cache) AllTB(ns, db string) (out []*sql.DefineTableStatement, err error
return out.([]*sql.DefineTableStatement), nil return out.([]*sql.DefineTableStatement), nil
} }
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -547,7 +549,7 @@ func (c *Cache) AllTB(ns, db string) (out []*sql.DefineTableStatement, err error
} }
func (c *Cache) GetTB(ns, db, tb string) (val *sql.DefineTableStatement, err error) { func (c *Cache) GetTB(ctx context.Context, ns, db, tb string) (val *sql.DefineTableStatement, err error) {
var kv kvs.KV var kv kvs.KV
@ -560,7 +562,7 @@ func (c *Cache) GetTB(ns, db, tb string) (val *sql.DefineTableStatement, err err
return out.(*sql.DefineTableStatement), nil return out.(*sql.DefineTableStatement), nil
} }
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -577,9 +579,9 @@ func (c *Cache) GetTB(ns, db, tb string) (val *sql.DefineTableStatement, err err
} }
func (c *Cache) AddTB(ns, db, tb string) (val *sql.DefineTableStatement, err error) { func (c *Cache) AddTB(ctx context.Context, ns, db, tb string) (val *sql.DefineTableStatement, err error) {
if _, err = c.AddDB(ns, db); err != nil { if _, err = c.AddDB(ctx, ns, db); err != nil {
return return
} }
@ -594,7 +596,7 @@ func (c *Cache) AddTB(ns, db, tb string) (val *sql.DefineTableStatement, err err
return out.(*sql.DefineTableStatement), nil return out.(*sql.DefineTableStatement), nil
} }
if kv, _ = c.TX.Get(0, key.Encode()); kv.Exi() { if kv, _ = c.TX.Get(ctx, 0, key.Encode()); kv.Exi() {
val = &sql.DefineTableStatement{} val = &sql.DefineTableStatement{}
val.Decode(kv.Val()) val.Decode(kv.Val())
c.put(key, val) c.put(key, val)
@ -602,7 +604,7 @@ func (c *Cache) AddTB(ns, db, tb string) (val *sql.DefineTableStatement, err err
} }
val = &sql.DefineTableStatement{Name: sql.NewIdent(tb)} val = &sql.DefineTableStatement{Name: sql.NewIdent(tb)}
c.TX.PutC(0, key.Encode(), val.Encode(), nil) c.TX.PutC(ctx, 0, key.Encode(), val.Encode(), nil)
c.put(key, val) c.put(key, val)
@ -620,7 +622,7 @@ func (c *Cache) DelTB(ns, db, tb string) {
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllEV(ns, db, tb string) (out []*sql.DefineEventStatement, err error) { func (c *Cache) AllEV(ctx context.Context, ns, db, tb string) (out []*sql.DefineEventStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
@ -630,7 +632,7 @@ func (c *Cache) AllEV(ns, db, tb string) (out []*sql.DefineEventStatement, err e
return out.([]*sql.DefineEventStatement), nil return out.([]*sql.DefineEventStatement), nil
} }
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -646,7 +648,7 @@ func (c *Cache) AllEV(ns, db, tb string) (out []*sql.DefineEventStatement, err e
} }
func (c *Cache) GetEV(ns, db, tb, ev string) (val *sql.DefineEventStatement, err error) { func (c *Cache) GetEV(ctx context.Context, ns, db, tb, ev string) (val *sql.DefineEventStatement, err error) {
var kv kvs.KV var kv kvs.KV
@ -656,7 +658,7 @@ func (c *Cache) GetEV(ns, db, tb, ev string) (val *sql.DefineEventStatement, err
return out.(*sql.DefineEventStatement), nil return out.(*sql.DefineEventStatement), nil
} }
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -683,7 +685,7 @@ func (c *Cache) DelEV(ns, db, tb, ev string) {
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllFD(ns, db, tb string) (out []*sql.DefineFieldStatement, err error) { func (c *Cache) AllFD(ctx context.Context, ns, db, tb string) (out []*sql.DefineFieldStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
@ -693,7 +695,7 @@ func (c *Cache) AllFD(ns, db, tb string) (out []*sql.DefineFieldStatement, err e
return out.([]*sql.DefineFieldStatement), nil return out.([]*sql.DefineFieldStatement), nil
} }
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -709,7 +711,7 @@ func (c *Cache) AllFD(ns, db, tb string) (out []*sql.DefineFieldStatement, err e
} }
func (c *Cache) GetFD(ns, db, tb, fd string) (val *sql.DefineFieldStatement, err error) { func (c *Cache) GetFD(ctx context.Context, ns, db, tb, fd string) (val *sql.DefineFieldStatement, err error) {
var kv kvs.KV var kv kvs.KV
@ -719,7 +721,7 @@ func (c *Cache) GetFD(ns, db, tb, fd string) (val *sql.DefineFieldStatement, err
return out.(*sql.DefineFieldStatement), nil return out.(*sql.DefineFieldStatement), nil
} }
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -746,7 +748,7 @@ func (c *Cache) DelFD(ns, db, tb, fd string) {
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllIX(ns, db, tb string) (out []*sql.DefineIndexStatement, err error) { func (c *Cache) AllIX(ctx context.Context, ns, db, tb string) (out []*sql.DefineIndexStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
@ -756,7 +758,7 @@ func (c *Cache) AllIX(ns, db, tb string) (out []*sql.DefineIndexStatement, err e
return out.([]*sql.DefineIndexStatement), nil return out.([]*sql.DefineIndexStatement), nil
} }
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -772,7 +774,7 @@ func (c *Cache) AllIX(ns, db, tb string) (out []*sql.DefineIndexStatement, err e
} }
func (c *Cache) GetIX(ns, db, tb, ix string) (val *sql.DefineIndexStatement, err error) { func (c *Cache) GetIX(ctx context.Context, ns, db, tb, ix string) (val *sql.DefineIndexStatement, err error) {
var kv kvs.KV var kv kvs.KV
@ -782,7 +784,7 @@ func (c *Cache) GetIX(ns, db, tb, ix string) (val *sql.DefineIndexStatement, err
return out.(*sql.DefineIndexStatement), nil return out.(*sql.DefineIndexStatement), nil
} }
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -809,7 +811,7 @@ func (c *Cache) DelIX(ns, db, tb, ix string) {
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllFT(ns, db, tb string) (out []*sql.DefineTableStatement, err error) { func (c *Cache) AllFT(ctx context.Context, ns, db, tb string) (out []*sql.DefineTableStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
@ -819,7 +821,7 @@ func (c *Cache) AllFT(ns, db, tb string) (out []*sql.DefineTableStatement, err e
return out.([]*sql.DefineTableStatement), nil return out.([]*sql.DefineTableStatement), nil
} }
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -835,7 +837,7 @@ func (c *Cache) AllFT(ns, db, tb string) (out []*sql.DefineTableStatement, err e
} }
func (c *Cache) GetFT(ns, db, tb, ft string) (val *sql.DefineTableStatement, err error) { func (c *Cache) GetFT(ctx context.Context, ns, db, tb, ft string) (val *sql.DefineTableStatement, err error) {
var kv kvs.KV var kv kvs.KV
@ -845,7 +847,7 @@ func (c *Cache) GetFT(ns, db, tb, ft string) (val *sql.DefineTableStatement, err
return out.(*sql.DefineTableStatement), nil return out.(*sql.DefineTableStatement), nil
} }
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }
@ -872,7 +874,7 @@ func (c *Cache) DelFT(ns, db, tb, ft string) {
// -------------------------------------------------- // --------------------------------------------------
func (c *Cache) AllLV(ns, db, tb string) (out []*sql.LiveStatement, err error) { func (c *Cache) AllLV(ctx context.Context, ns, db, tb string) (out []*sql.LiveStatement, err error) {
var kvs []kvs.KV var kvs []kvs.KV
@ -882,7 +884,7 @@ func (c *Cache) AllLV(ns, db, tb string) (out []*sql.LiveStatement, err error) {
return out.([]*sql.LiveStatement), nil return out.([]*sql.LiveStatement), nil
} }
if kvs, err = c.TX.GetP(0, key.Encode(), 0); err != nil { if kvs, err = c.TX.GetP(ctx, 0, key.Encode(), 0); err != nil {
return return
} }
@ -898,7 +900,7 @@ func (c *Cache) AllLV(ns, db, tb string) (out []*sql.LiveStatement, err error) {
} }
func (c *Cache) GetLV(ns, db, tb, lv string) (val *sql.LiveStatement, err error) { func (c *Cache) GetLV(ctx context.Context, ns, db, tb, lv string) (val *sql.LiveStatement, err error) {
var kv kvs.KV var kv kvs.KV
@ -908,7 +910,7 @@ func (c *Cache) GetLV(ns, db, tb, lv string) (val *sql.LiveStatement, err error)
return out.(*sql.LiveStatement), nil return out.(*sql.LiveStatement), nil
} }
if kv, err = c.TX.Get(0, key.Encode()); err != nil { if kv, err = c.TX.Get(ctx, 0, key.Encode()); err != nil {
return nil, err return nil, err
} }

20
web/auth.go
View file

@ -248,7 +248,7 @@ func checkBasics(c *fibre.Context, info string, callback func() error) (err erro
u := string(cred[0]) u := string(cred[0])
p := string(cred[1]) p := string(cred[1])
if _, err = signinNS(n, u, p); err == nil { if _, err = signinNS(c, n, u, p); err == nil {
auth.Kind = cnf.AuthNS auth.Kind = cnf.AuthNS
auth.Possible.NS = n auth.Possible.NS = n
auth.Possible.DB = "*" auth.Possible.DB = "*"
@ -264,7 +264,7 @@ func checkBasics(c *fibre.Context, info string, callback func() error) (err erro
u := string(cred[0]) u := string(cred[0])
p := string(cred[1]) p := string(cred[1])
if _, err = signinDB(n, d, u, p); err == nil { if _, err = signinDB(c, n, d, u, p); err == nil {
auth.Kind = cnf.AuthDB auth.Kind = cnf.AuthDB
auth.Possible.NS = n auth.Possible.NS = n
auth.Possible.DB = d auth.Possible.DB = d
@ -297,6 +297,10 @@ func checkBearer(c *fibre.Context, info string, callback func() error) (err erro
defer txn.Cancel() defer txn.Cancel()
// Get the current context.
ctx := c.Context()
// Setup the kvs layer cache. // Setup the kvs layer cache.
cache := mem.NewWithTX(txn) cache := mem.NewWithTX(txn)
@ -331,7 +335,7 @@ func checkBearer(c *fibre.Context, info string, callback func() error) (err erro
if nsk && dbk && sck && tkk { if nsk && dbk && sck && tkk {
scp, err := cache.GetSC(nsv, dbv, scv) scp, err := cache.GetSC(ctx, nsv, dbv, scv)
if err != nil { if err != nil {
return nil, fmt.Errorf("Credentials failed") return nil, fmt.Errorf("Credentials failed")
} }
@ -377,7 +381,7 @@ func checkBearer(c *fibre.Context, info string, callback func() error) (err erro
} }
if tkv != "default" { if tkv != "default" {
key, err := cache.GetST(nsv, dbv, scv, tkv) key, err := cache.GetST(ctx, nsv, dbv, scv, tkv)
if err != nil { if err != nil {
return nil, fmt.Errorf("Credentials failed") return nil, fmt.Errorf("Credentials failed")
} }
@ -394,7 +398,7 @@ func checkBearer(c *fibre.Context, info string, callback func() error) (err erro
} else if nsk && dbk && tkk { } else if nsk && dbk && tkk {
if tkv != "default" { if tkv != "default" {
key, err := cache.GetDT(nsv, dbv, tkv) key, err := cache.GetDT(ctx, nsv, dbv, tkv)
if err != nil { if err != nil {
return nil, fmt.Errorf("Credentials failed") return nil, fmt.Errorf("Credentials failed")
} }
@ -404,7 +408,7 @@ func checkBearer(c *fibre.Context, info string, callback func() error) (err erro
auth.Kind = cnf.AuthDB auth.Kind = cnf.AuthDB
return key.Code, nil return key.Code, nil
} else if usk { } else if usk {
usr, err := cache.GetDU(nsv, dbv, usv) usr, err := cache.GetDU(ctx, nsv, dbv, usv)
if err != nil { if err != nil {
return nil, fmt.Errorf("Credentials failed") return nil, fmt.Errorf("Credentials failed")
} }
@ -415,7 +419,7 @@ func checkBearer(c *fibre.Context, info string, callback func() error) (err erro
} else if nsk && tkk { } else if nsk && tkk {
if tkv != "default" { if tkv != "default" {
key, err := cache.GetNT(nsv, tkv) key, err := cache.GetNT(ctx, nsv, tkv)
if err != nil { if err != nil {
return nil, fmt.Errorf("Credentials failed") return nil, fmt.Errorf("Credentials failed")
} }
@ -425,7 +429,7 @@ func checkBearer(c *fibre.Context, info string, callback func() error) (err erro
auth.Kind = cnf.AuthNS auth.Kind = cnf.AuthNS
return key.Code, nil return key.Code, nil
} else if usk { } else if usk {
usr, err := cache.GetNU(nsv, usv) usr, err := cache.GetNU(ctx, nsv, usv)
if err != nil { if err != nil {
return nil, fmt.Errorf("Credentials failed") return nil, fmt.Errorf("Credentials failed")
} }

26
web/signin.go
View file

@ -93,6 +93,10 @@ func signinInternal(c *fibre.Context, vars map[string]interface{}) (str string,
defer txn.Cancel() defer txn.Cancel()
// Get the current context.
ctx := c.Context()
// Give full permissions to scope. // Give full permissions to scope.
c.Set(varKeyAuth, &cnf.Auth{Kind: cnf.AuthDB}) c.Set(varKeyAuth, &cnf.Auth{Kind: cnf.AuthDB})
@ -103,7 +107,7 @@ func signinInternal(c *fibre.Context, vars map[string]interface{}) (str string,
// Get the specified signin scope. // Get the specified signin scope.
if scp, err = mem.NewWithTX(txn).GetSC(n, d, s); err != nil { if scp, err = mem.NewWithTX(txn).GetSC(ctx, n, d, s); err != nil {
m := "Authentication scope does not exist" m := "Authentication scope does not exist"
return str, fibre.NewHTTPError(403).WithFields(f).WithMessage(m) return str, fibre.NewHTTPError(403).WithFields(f).WithMessage(m)
} }
@ -233,7 +237,7 @@ func signinInternal(c *fibre.Context, vars map[string]interface{}) (str string,
// Start a new read transaction. // Start a new read transaction.
if usr, err = signinDB(n, d, u, p); err != nil { if usr, err = signinDB(c, n, d, u, p); err != nil {
return str, err return str, err
} }
@ -287,7 +291,7 @@ func signinInternal(c *fibre.Context, vars map[string]interface{}) (str string,
return str, fibre.NewHTTPError(403).WithFields(f).WithMessage(m) return str, fibre.NewHTTPError(403).WithFields(f).WithMessage(m)
} }
if usr, err = signinNS(n, u, p); err != nil { if usr, err = signinNS(c, n, u, p); err != nil {
return str, err return str, err
} }
@ -319,7 +323,7 @@ func signinInternal(c *fibre.Context, vars map[string]interface{}) (str string,
} }
func signinDB(n, d, u, p string) (usr *sql.DefineLoginStatement, err error) { func signinDB(c *fibre.Context, n, d, u, p string) (usr *sql.DefineLoginStatement, err error) {
var txn kvs.TX var txn kvs.TX
@ -333,6 +337,10 @@ func signinDB(n, d, u, p string) (usr *sql.DefineLoginStatement, err error) {
defer txn.Cancel() defer txn.Cancel()
// Get the current context.
ctx := c.Context()
// Specify fields to show in logs. // Specify fields to show in logs.
f := map[string]interface{}{"ns": n, "db": d, "du": u} f := map[string]interface{}{"ns": n, "db": d, "du": u}
@ -346,7 +354,7 @@ func signinDB(n, d, u, p string) (usr *sql.DefineLoginStatement, err error) {
// Get the specified namespace login. // Get the specified namespace login.
if usr, err = mem.NewWithTX(txn).GetDU(n, d, u); err != nil { if usr, err = mem.NewWithTX(txn).GetDU(ctx, n, d, u); err != nil {
m := "Database login does not exist" m := "Database login does not exist"
return nil, fibre.NewHTTPError(403).WithFields(f).WithMessage(m) return nil, fibre.NewHTTPError(403).WithFields(f).WithMessage(m)
} }
@ -362,7 +370,7 @@ func signinDB(n, d, u, p string) (usr *sql.DefineLoginStatement, err error) {
} }
func signinNS(n, u, p string) (usr *sql.DefineLoginStatement, err error) { func signinNS(c *fibre.Context, n, u, p string) (usr *sql.DefineLoginStatement, err error) {
var txn kvs.TX var txn kvs.TX
@ -376,6 +384,10 @@ func signinNS(n, u, p string) (usr *sql.DefineLoginStatement, err error) {
defer txn.Cancel() defer txn.Cancel()
// Get the current context.
ctx := c.Context()
// Specify fields to show in logs. // Specify fields to show in logs.
f := map[string]interface{}{"ns": n, "nu": u} f := map[string]interface{}{"ns": n, "nu": u}
@ -389,7 +401,7 @@ func signinNS(n, u, p string) (usr *sql.DefineLoginStatement, err error) {
// Get the specified namespace login. // Get the specified namespace login.
if usr, err = mem.NewWithTX(txn).GetNU(n, u); err != nil { if usr, err = mem.NewWithTX(txn).GetNU(ctx, n, u); err != nil {
m := "Namespace login does not exist" m := "Namespace login does not exist"
return nil, fibre.NewHTTPError(403).WithFields(f).WithMessage(m) return nil, fibre.NewHTTPError(403).WithFields(f).WithMessage(m)
} }

6
web/signup.go
View file

@ -92,6 +92,10 @@ func signupInternal(c *fibre.Context, vars map[string]interface{}) (str string,
defer txn.Cancel() defer txn.Cancel()
// Get the current context.
ctx := c.Context()
// Give full permissions to scope. // Give full permissions to scope.
c.Set(varKeyAuth, &cnf.Auth{Kind: cnf.AuthDB}) c.Set(varKeyAuth, &cnf.Auth{Kind: cnf.AuthDB})
@ -102,7 +106,7 @@ func signupInternal(c *fibre.Context, vars map[string]interface{}) (str string,
// Get the specified signin scope. // Get the specified signin scope.
if scp, err = mem.NewWithTX(txn).GetSC(n, d, s); err != nil { if scp, err = mem.NewWithTX(txn).GetSC(ctx, n, d, s); err != nil {
m := "Authentication scope does not exist" m := "Authentication scope does not exist"
return str, fibre.NewHTTPError(403).WithFields(f).WithMessage(m) return str, fibre.NewHTTPError(403).WithFields(f).WithMessage(m)
} }