My own copy of Tangled :)
Revert "appview/db: transactions all the things"
This reverts commit 510bb2d20c7ddef4b5ed215a3194f60a11ca3cc6.
author
Akshay
date
(Feb 5, 2025, 5:26 PM UTC)
commit
8fe42d6c
8fe42d6c75cc6c142dc1493c2a86f5204e14ff37
parent
6c146525
6c14652536d5db78cce208b00baf66a8cf214a2a
+47
-182
+2
-2
appview/db/db.go
+2
-2
appview/db/db.go
+4
-11
appview/db/pubkeys.go
+4
-11
appview/db/pubkeys.go
···
1
1
package db
2
2
3
3
import (
4
-
"database/sql"
5
4
"encoding/json"
6
5
"time"
7
6
)
8
7
9
8
func (d *DB) AddPublicKey(did, name, key string) error {
10
9
query := `insert into public_keys (did, name, key) values (?, ?, ?)`
11
-
_, err := d.Db.Exec(query, did, name, key)
12
-
return err
13
-
}
14
-
15
-
func (d *DB) AddPublicKeyTx(tx *sql.Tx, did, name, key string) error {
16
-
query := `insert into public_keys (did, name, key) values (?, ?, ?)`
17
-
_, err := tx.Exec(query, did, name, key)
10
+
_, err := d.db.Exec(query, did, name, key)
18
11
return err
19
12
}
20
13
21
14
func (d *DB) RemovePublicKey(did string) error {
22
15
query := `delete from public_keys where did = ?`
23
-
_, err := d.Db.Exec(query, did)
16
+
_, err := d.db.Exec(query, did)
24
17
return err
25
18
}
26
19
···
45
38
func (d *DB) GetAllPublicKeys() ([]PublicKey, error) {
46
39
var keys []PublicKey
47
40
48
-
rows, err := d.Db.Query(`select key, name, did, created from public_keys`)
41
+
rows, err := d.db.Query(`select key, name, did, created from public_keys`)
49
42
if err != nil {
50
43
return nil, err
51
44
}
···
71
64
func (d *DB) GetPublicKeys(did string) ([]PublicKey, error) {
72
65
var keys []PublicKey
73
66
74
-
rows, err := d.Db.Query(`select did, key, name, created from public_keys where did = ?`, did)
67
+
rows, err := d.db.Query(`select did, key, name, created from public_keys where did = ?`, did)
75
68
if err != nil {
76
69
return nil, err
77
70
}
+5
-58
appview/db/registration.go
+5
-58
appview/db/registration.go
···
35
35
func (d *DB) RegistrationsByDid(did string) ([]Registration, error) {
36
36
var registrations []Registration
37
37
38
-
rows, err := d.Db.Query(`
38
+
rows, err := d.db.Query(`
39
39
select domain, did, created, registered from registrations
40
40
where did = ?
41
41
`, did)
···
75
75
var registeredAt *int64
76
76
var registration Registration
77
77
78
-
err := d.Db.QueryRow(`
79
-
select domain, did, created, registered from registrations
80
-
where domain = ?
81
-
`, domain).Scan(®istration.Domain, ®istration.ByDid, &createdAt, ®isteredAt)
82
-
83
-
if err != nil {
84
-
if err == sql.ErrNoRows {
85
-
return nil, nil
86
-
} else {
87
-
return nil, err
88
-
}
89
-
}
90
-
91
-
createdAtTime := time.Unix(*createdAt, 0)
92
-
var registeredAtTime *time.Time
93
-
if registeredAt != nil {
94
-
x := time.Unix(*registeredAt, 0)
95
-
registeredAtTime = &x
96
-
}
97
-
98
-
registration.Created = &createdAtTime
99
-
registration.Registered = registeredAtTime
100
-
101
-
return ®istration, nil
102
-
}
103
-
104
-
func (d *DB) RegistrationByDomainTx(tx *sql.Tx, domain string) (*Registration, error) {
105
-
var createdAt *int64
106
-
var registeredAt *int64
107
-
var registration Registration
108
-
109
-
err := tx.QueryRow(`
78
+
err := d.db.QueryRow(`
110
79
select domain, did, created, registered from registrations
111
80
where domain = ?
112
81
`, domain).Scan(®istration.Domain, ®istration.ByDid, &createdAt, ®isteredAt)
···
153
122
154
123
secret := uuid.New().String()
155
124
156
-
_, err = d.Db.Exec(`
125
+
_, err = d.db.Exec(`
157
126
insert into registrations (domain, did, secret)
158
127
values (?, ?, ?)
159
128
on conflict(domain) do update set did = excluded.did, secret = excluded.secret
···
167
136
}
168
137
169
138
func (d *DB) GetRegistrationKey(domain string) (string, error) {
170
-
res := d.Db.QueryRow(`select secret from registrations where domain = ?`, domain)
171
-
172
-
var secret string
173
-
err := res.Scan(&secret)
174
-
if err != nil || secret == "" {
175
-
return "", err
176
-
}
177
-
178
-
return secret, nil
179
-
}
180
-
181
-
func (d *DB) GetRegistrationKeyTx(tx *sql.Tx, domain string) (string, error) {
182
-
res := tx.QueryRow(`select secret from registrations where domain = ?`, domain)
139
+
res := d.db.QueryRow(`select secret from registrations where domain = ?`, domain)
183
140
184
141
var secret string
185
142
err := res.Scan(&secret)
···
191
148
}
192
149
193
150
func (d *DB) Register(domain string) error {
194
-
_, err := d.Db.Exec(`
195
-
update registrations
196
-
set registered = strftime('%s', 'now')
197
-
where domain = ?;
198
-
`, domain)
199
-
200
-
return err
201
-
}
202
-
203
-
func (d *DB) RegisterTx(tx *sql.Tx, domain string) error {
204
-
_, err := tx.Exec(`
151
+
_, err := d.db.Exec(`
205
152
update registrations
206
153
set registered = strftime('%s', 'now')
207
154
where domain = ?;
+4
-11
appview/db/repos.go
+4
-11
appview/db/repos.go
···
1
1
package db
2
2
3
-
import "database/sql"
4
-
5
3
type Repo struct {
6
4
Did string
7
5
Name string
···
12
10
func (d *DB) GetAllReposByDid(did string) ([]Repo, error) {
13
11
var repos []Repo
14
12
15
-
rows, err := d.Db.Query(`select did, name, knot, created from repos where did = ?`, did)
13
+
rows, err := d.db.Query(`select did, name, knot, created from repos where did = ?`, did)
16
14
if err != nil {
17
15
return nil, err
18
16
}
···
38
36
func (d *DB) GetRepo(did, name string) (*Repo, error) {
39
37
var repo Repo
40
38
41
-
row := d.Db.QueryRow(`select did, name, knot, created from repos where did = ? and name = ?`, did, name)
39
+
row := d.db.QueryRow(`select did, name, knot, created from repos where did = ? and name = ?`, did, name)
42
40
var createdAt *int64
43
41
if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt); err != nil {
44
42
return nil, err
···
49
47
}
50
48
51
49
func (d *DB) AddRepo(repo *Repo) error {
52
-
_, err := d.Db.Exec(`insert into repos (did, name, knot) values (?, ?, ?)`, repo.Did, repo.Name, repo.Knot)
53
-
return err
54
-
}
55
-
56
-
func (d *DB) AddRepoTx(tx *sql.Tx, repo *Repo) error {
57
-
_, err := tx.Exec(`insert into repos (did, name, knot) values (?, ?, ?)`, repo.Did, repo.Name, repo.Knot)
50
+
_, err := d.db.Exec(`insert into repos (did, name, knot) values (?, ?, ?)`, repo.Did, repo.Name, repo.Knot)
58
51
return err
59
52
}
60
53
61
54
func (d *DB) RemoveRepo(did, name, knot string) error {
62
-
_, err := d.Db.Exec(`delete from repos where did = ? and name = ? and knot = ?`, did, name, knot)
55
+
_, err := d.db.Exec(`delete from repos where did = ? and name = ? and knot = ?`, did, name, knot)
63
56
return err
64
57
}
+32
-100
appview/state/state.go
+32
-100
appview/state/state.go
···
200
200
return
201
201
}
202
202
203
-
// Start transaction
204
-
tx, err := s.db.Db.Begin()
205
-
if err != nil {
206
-
log.Printf("failed to start transaction: %s", err)
207
-
http.Error(w, "Internal server error", http.StatusInternalServerError)
208
-
return
209
-
}
210
-
defer tx.Rollback() // Will rollback if not committed
211
-
212
-
if err := s.db.AddPublicKeyTx(tx, did, name, key); err != nil {
203
+
if err := s.db.AddPublicKey(did, name, key); err != nil {
213
204
log.Printf("adding public key: %s", err)
214
205
return
215
206
}
···
232
223
return
233
224
}
234
225
235
-
// If everything succeeded, commit the transaction
236
-
if err := tx.Commit(); err != nil {
237
-
log.Printf("failed to commit transaction: %s", err)
238
-
http.Error(w, "Internal server error", http.StatusInternalServerError)
239
-
return
240
-
}
241
-
242
226
log.Println("created atproto record: ", resp.Uri)
243
227
244
228
return
···
256
240
}
257
241
log.Println("checking ", domain)
258
242
259
-
// Start transaction
260
-
tx, err := s.db.Db.Begin()
261
-
if err != nil {
262
-
log.Printf("failed to start transaction: %s", err)
263
-
http.Error(w, "Internal server error", http.StatusInternalServerError)
264
-
return
265
-
}
266
-
defer tx.Rollback() // Will rollback if not committed
267
-
268
-
secret, err := s.db.GetRegistrationKeyTx(tx, domain)
243
+
secret, err := s.db.GetRegistrationKey(domain)
269
244
if err != nil {
270
245
log.Printf("no key found for domain %s: %s\n", domain, err)
271
246
return
···
310
285
return
311
286
}
312
287
313
-
// mark as registered within transaction
314
-
err = s.db.RegisterTx(tx, domain)
288
+
// mark as registered
289
+
err = s.db.Register(domain)
315
290
if err != nil {
316
291
log.Println("failed to register domain", err)
317
292
http.Error(w, err.Error(), http.StatusInternalServerError)
318
293
return
319
294
}
320
295
321
-
// set permissions for this did as owner within transaction
322
-
reg, err := s.db.RegistrationByDomainTx(tx, domain)
296
+
// set permissions for this did as owner
297
+
reg, err := s.db.RegistrationByDomain(domain)
323
298
if err != nil {
324
299
log.Println("failed to register domain", err)
325
300
http.Error(w, err.Error(), http.StatusInternalServerError)
326
301
return
327
302
}
328
303
329
-
// add basic acls for this domain within transaction
304
+
// add basic acls for this domain
330
305
err = s.enforcer.AddDomain(domain)
331
306
if err != nil {
332
307
log.Println("failed to setup owner of domain", err)
···
334
309
return
335
310
}
336
311
337
-
// add this did as owner of this domain within transaction
312
+
// add this did as owner of this domain
338
313
err = s.enforcer.AddOwner(domain, reg.ByDid)
339
314
if err != nil {
340
315
log.Println("failed to setup owner of domain", err)
341
316
http.Error(w, err.Error(), http.StatusInternalServerError)
342
-
return
343
-
}
344
-
345
-
// Commit transaction
346
-
if err := tx.Commit(); err != nil {
347
-
log.Printf("failed to commit transaction: %s", err)
348
-
http.Error(w, "Internal server error", http.StatusInternalServerError)
349
317
return
350
318
}
351
319
···
443
411
}
444
412
log.Printf("adding %s to %s\n", memberIdent.Handle.String(), domain)
445
413
446
-
// Start transaction
447
-
tx, err := s.db.Db.Begin()
414
+
// announce this relation into the firehose, store into owners' pds
415
+
client, _ := s.auth.AuthorizedClient(r)
416
+
currentUser := s.auth.GetUser(r)
417
+
addedAt := time.Now().Format(time.RFC3339)
418
+
resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
419
+
Collection: tangled.KnotMemberNSID,
420
+
Repo: currentUser.Did,
421
+
Rkey: s.TID(),
422
+
Record: &lexutil.LexiconTypeDecoder{
423
+
Val: &tangled.KnotMember{
424
+
Member: memberIdent.DID.String(),
425
+
Domain: domain,
426
+
AddedAt: &addedAt,
427
+
}},
428
+
})
429
+
// invalid record
448
430
if err != nil {
449
-
log.Printf("failed to start transaction: %s", err)
450
-
http.Error(w, "Internal server error", http.StatusInternalServerError)
431
+
log.Printf("failed to create record: %s", err)
451
432
return
452
433
}
453
-
defer tx.Rollback() // Will rollback if not committed
434
+
log.Println("created atproto record: ", resp.Uri)
454
435
455
-
// Get registration key within transaction
456
-
secret, err := s.db.GetRegistrationKeyTx(tx, domain)
436
+
secret, err := s.db.GetRegistrationKey(domain)
457
437
if err != nil {
458
438
log.Printf("no key found for domain %s: %s\n", domain, err)
459
439
return
460
440
}
461
441
462
-
// Make the external call to the knot server
463
442
ksClient, err := NewSignedClient(domain, secret)
464
443
if err != nil {
465
444
log.Println("failed to create client to ", domain)
···
468
447
469
448
ksResp, err := ksClient.AddMember(memberIdent.DID.String(), []string{})
470
449
if err != nil {
471
-
log.Printf("failed to make request to %s: %s", domain, err)
472
-
return
450
+
log.Printf("failet to make request to %s: %s", domain, err)
473
451
}
474
452
475
453
if ksResp.StatusCode != http.StatusNoContent {
···
477
455
return
478
456
}
479
457
480
-
// Create ATProto record within transaction
481
-
client, _ := s.auth.AuthorizedClient(r)
482
-
currentUser := s.auth.GetUser(r)
483
-
addedAt := time.Now().Format(time.RFC3339)
484
-
resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
485
-
Collection: tangled.KnotMemberNSID,
486
-
Repo: currentUser.Did,
487
-
Rkey: s.TID(),
488
-
Record: &lexutil.LexiconTypeDecoder{
489
-
Val: &tangled.KnotMember{
490
-
Member: memberIdent.DID.String(),
491
-
Domain: domain,
492
-
AddedAt: &addedAt,
493
-
}},
494
-
})
495
-
if err != nil {
496
-
log.Printf("failed to create record: %s", err)
497
-
return
498
-
}
499
-
500
-
// Update RBAC within transaction
501
458
err = s.enforcer.AddMember(domain, memberIdent.DID.String())
502
459
if err != nil {
503
460
w.Write([]byte(fmt.Sprint("failed to add member: ", err)))
504
461
return
505
462
}
506
463
507
-
// If everything succeeded, commit the transaction
508
-
if err := tx.Commit(); err != nil {
509
-
log.Printf("failed to commit transaction: %s", err)
510
-
http.Error(w, "Internal server error", http.StatusInternalServerError)
511
-
return
512
-
}
513
-
514
-
log.Println("created atproto record: ", resp.Uri)
515
464
w.Write([]byte(fmt.Sprint("added member: ", memberIdent.Handle.String())))
516
465
}
517
466
···
545
494
return
546
495
}
547
496
548
-
// Start transaction
549
-
tx, err := s.db.Db.Begin()
550
-
if err != nil {
551
-
log.Printf("failed to start transaction: %s", err)
552
-
http.Error(w, "Internal server error", http.StatusInternalServerError)
553
-
return
554
-
}
555
-
defer tx.Rollback() // Will rollback if not committed
556
-
557
-
secret, err := s.db.GetRegistrationKeyTx(tx, domain)
497
+
secret, err := s.db.GetRegistrationKey(domain)
558
498
if err != nil {
559
499
log.Printf("no key found for domain %s: %s\n", domain, err)
560
500
return
···
563
503
client, err := NewSignedClient(domain, secret)
564
504
if err != nil {
565
505
log.Println("failed to create client to ", domain)
566
-
return
567
506
}
568
507
569
508
resp, err := client.NewRepo(user.Did, repoName)
···
576
515
return
577
516
}
578
517
579
-
// add to local db within transaction
518
+
// add to local db
580
519
repo := &db.Repo{
581
520
Did: user.Did,
582
521
Name: repoName,
583
522
Knot: domain,
584
523
}
585
-
err = s.db.AddRepoTx(tx, repo)
524
+
err = s.db.AddRepo(repo)
586
525
if err != nil {
587
526
log.Println("failed to add repo to db", err)
588
527
return
589
528
}
590
529
591
-
// acls within transaction
530
+
// acls
592
531
err = s.enforcer.AddRepo(user.Did, domain, filepath.Join(user.Did, repoName))
593
532
if err != nil {
594
533
log.Println("failed to set up acls", err)
595
-
return
596
-
}
597
-
598
-
// Commit transaction
599
-
if err := tx.Commit(); err != nil {
600
-
log.Printf("failed to commit transaction: %s", err)
601
-
http.Error(w, "Internal server error", http.StatusInternalServerError)
602
534
return
603
535
}
604
536