forked from
tangled.org/core
Monorepo for Tangled
appview: handle non-unique publicKey records
- upsert public key to handle record update event
- don't delete by pair of name and key. delete by name or rkey instead.
Signed-off-by: Seongmin Lee <git@boltless.me>
+108
-47
+17
-7
appview/db/pubkeys.go
+17
-7
appview/db/pubkeys.go
···
5
5
"time"
6
6
)
7
7
8
-
func AddPublicKey(e Execer, did, name, key, rkey string) error {
8
+
func UpsertPublicKey(e Execer, pubKey models.PublicKey) error {
9
9
_, err := e.Exec(
10
-
`insert or ignore into public_keys (did, name, key, rkey)
11
-
values (?, ?, ?, ?)`,
12
-
did, name, key, rkey)
10
+
`insert into public_keys (did, rkey, name, key, created)
11
+
values (?, ?, ?, ?, ?)
12
+
on conflict(did, rkey) do update set
13
+
name = excluded.name,
14
+
key = excluded.key,
15
+
created = excluded.created`,
16
+
pubKey.Did,
17
+
pubKey.Rkey,
18
+
pubKey.Name,
19
+
pubKey.Key,
20
+
pubKey.Created.Format(time.RFC3339),
21
+
)
13
22
return err
14
23
}
15
24
16
-
func DeletePublicKey(e Execer, did, name, key string) error {
25
+
// for public_keys with empty rkey
26
+
func DeletePublicKeyLegacy(e Execer, did, name string) error {
17
27
_, err := e.Exec(`
18
28
delete from public_keys
19
-
where did = ? and name = ? and key = ?`,
20
-
did, name, key)
29
+
where did = ? and name = ? and rkey = ''`,
30
+
did, name)
21
31
return err
22
32
}
23
33
+13
-3
appview/ingester.go
+13
-3
appview/ingester.go
···
131
131
if err != nil {
132
132
return fmt.Errorf("failed to %s star record: %w", e.Commit.Operation, err)
133
133
}
134
+
l.Info("processed star", "operation", e.Commit.Operation, "rkey", e.Commit.RKey)
134
135
135
136
return nil
136
137
}
···
164
165
if err != nil {
165
166
return fmt.Errorf("failed to %s follow record: %w", e.Commit.Operation, err)
166
167
}
168
+
l.Info("processed follow", "operation", e.Commit.Operation, "rkey", e.Commit.RKey)
167
169
168
170
return nil
169
171
}
···
185
187
l.Error("invalid record", "err", err)
186
188
return err
187
189
}
190
+
pubKey, err := models.PublicKeyFromRecord(syntax.DID(did), syntax.RecordKey(e.Commit.RKey), record)
191
+
if err != nil {
192
+
l.Error("invalid record", "err", err)
193
+
return err
194
+
}
195
+
if err := pubKey.Validate(); err != nil {
196
+
l.Error("invalid record", "err", err)
197
+
return err
198
+
}
188
199
189
-
name := record.Name
190
-
key := record.Key
191
-
err = db.AddPublicKey(i.Db, did, name, key, e.Commit.RKey)
200
+
err = db.UpsertPublicKey(i.Db, pubKey)
192
201
case jmodels.CommitOperationDelete:
193
202
l.Debug("processing delete of pubkey")
194
203
err = db.DeletePublicKeyByRkey(i.Db, did, e.Commit.RKey)
···
197
206
if err != nil {
198
207
return fmt.Errorf("failed to %s pubkey record: %w", e.Commit.Operation, err)
199
208
}
209
+
l.Info("processed pubkey", "operation", e.Commit.Operation, "rkey", e.Commit.RKey)
200
210
201
211
return nil
202
212
}
+38
appview/models/pubkey.go
+38
appview/models/pubkey.go
···
2
2
3
3
import (
4
4
"encoding/json"
5
+
"fmt"
5
6
"time"
7
+
8
+
"github.com/bluesky-social/indigo/atproto/syntax"
9
+
"github.com/gliderlabs/ssh"
10
+
"tangled.org/core/api/tangled"
6
11
)
7
12
8
13
type PublicKey struct {
···
23
28
Alias: (*Alias)(&p),
24
29
})
25
30
}
31
+
32
+
func (p *PublicKey) AsRecord() tangled.PublicKey {
33
+
return tangled.PublicKey{
34
+
Name: p.Name,
35
+
Key: p.Key,
36
+
CreatedAt: p.Created.Format(time.RFC3339),
37
+
}
38
+
}
39
+
40
+
var _ Validator = new(PublicKey)
41
+
42
+
func (p *PublicKey) Validate() error {
43
+
if _, _, _, _, err := ssh.ParseAuthorizedKey([]byte(p.Key)); err != nil {
44
+
return fmt.Errorf("invalid ssh key format: %w", err)
45
+
}
46
+
47
+
return nil
48
+
}
49
+
50
+
func PublicKeyFromRecord(did syntax.DID, rkey syntax.RecordKey, record tangled.PublicKey) (PublicKey, error) {
51
+
created, err := time.Parse(time.RFC3339, record.CreatedAt)
52
+
if err != nil {
53
+
return PublicKey{}, fmt.Errorf("invalid time format '%s'", record.CreatedAt)
54
+
}
55
+
56
+
return PublicKey{
57
+
Did: did.String(),
58
+
Rkey: rkey.String(),
59
+
Name: record.Name,
60
+
Key: record.Key,
61
+
Created: &created,
62
+
}, nil
63
+
}
+1
-1
appview/pages/templates/user/settings/fragments/keyListing.html
+1
-1
appview/pages/templates/user/settings/fragments/keyListing.html
···
19
19
<button
20
20
class="btn text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 gap-2 group"
21
21
title="Delete key"
22
-
hx-delete="/settings/keys?name={{urlquery $key.Name}}&rkey={{urlquery $key.Rkey}}&key={{urlquery $key.Key}}"
22
+
hx-delete="/settings/keys?name={{urlquery $key.Name}}&rkey={{urlquery $key.Rkey}}"
23
23
hx-swap="none"
24
24
hx-confirm="Are you sure you want to delete the key {{ $key.Name }}?"
25
25
>
+39
-36
appview/settings/settings.go
+39
-36
appview/settings/settings.go
···
24
24
comatproto "github.com/bluesky-social/indigo/api/atproto"
25
25
"github.com/bluesky-social/indigo/atproto/syntax"
26
26
lexutil "github.com/bluesky-social/indigo/lex/util"
27
-
"github.com/gliderlabs/ssh"
28
27
"github.com/google/uuid"
29
28
)
30
29
···
419
418
log.Println("unimplemented")
420
419
return
421
420
case http.MethodPut:
422
-
did := s.OAuth.GetDid(r)
423
-
key := r.FormValue("key")
424
-
key = strings.TrimSpace(key)
425
-
name := r.FormValue("name")
426
-
client, err := s.OAuth.AuthorizedClient(r)
427
-
if err != nil {
428
-
s.Pages.Notice(w, "settings-keys", "Failed to authorize. Try again later.")
429
-
return
421
+
created := time.Now()
422
+
pubKey := models.PublicKey{
423
+
Did: s.OAuth.GetDid(r),
424
+
Rkey: tid.TID(),
425
+
Name: r.FormValue("name"),
426
+
Key: strings.TrimSpace(r.FormValue("key")),
427
+
Created: &created,
430
428
}
431
429
432
-
_, _, _, _, err = ssh.ParseAuthorizedKey([]byte(key))
433
-
if err != nil {
430
+
if err := pubKey.Validate(); err != nil {
434
431
log.Printf("parsing public key: %s", err)
435
432
s.Pages.Notice(w, "settings-keys", "That doesn't look like a valid public key. Make sure it's a <strong>public</strong> key.")
436
433
return
437
434
}
438
435
439
-
rkey := tid.TID()
440
-
441
436
tx, err := s.Db.Begin()
442
437
if err != nil {
443
438
log.Printf("failed to start tx; adding public key: %s", err)
···
446
441
}
447
442
defer tx.Rollback()
448
443
449
-
if err := db.AddPublicKey(tx, did, name, key, rkey); err != nil {
444
+
if err = db.UpsertPublicKey(s.Db, pubKey); err != nil {
450
445
log.Printf("adding public key: %s", err)
451
446
s.Pages.Notice(w, "settings-keys", "Failed to add public key.")
447
+
return
448
+
}
449
+
450
+
client, err := s.OAuth.AuthorizedClient(r)
451
+
if err != nil {
452
+
s.Pages.Notice(w, "settings-keys", "Failed to authorize. Try again later.")
452
453
return
453
454
}
454
455
455
456
// store in pds too
457
+
record := pubKey.AsRecord()
456
458
resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
457
459
Collection: tangled.PublicKeyNSID,
458
-
Repo: did,
459
-
Rkey: rkey,
460
+
Repo: pubKey.Did,
461
+
Rkey: pubKey.Rkey,
460
462
Record: &lexutil.LexiconTypeDecoder{
461
-
Val: &tangled.PublicKey{
462
-
CreatedAt: time.Now().Format(time.RFC3339),
463
-
Key: key,
464
-
Name: name,
465
-
}},
463
+
Val: &record,
464
+
},
466
465
})
467
466
// invalid record
468
467
if err != nil {
···
489
488
490
489
name := q.Get("name")
491
490
rkey := q.Get("rkey")
492
-
key := q.Get("key")
493
491
494
492
log.Println(name)
495
493
log.Println(rkey)
496
-
log.Println(key)
497
494
498
-
client, err := s.OAuth.AuthorizedClient(r)
499
-
if err != nil {
500
-
log.Printf("failed to authorize client: %s", err)
501
-
s.Pages.Notice(w, "settings-keys", "Failed to authorize client.")
502
-
return
503
-
}
495
+
if rkey == "" {
496
+
if err := db.DeletePublicKeyLegacy(s.Db, did, name); err != nil {
497
+
log.Printf("removing public key: %s", err)
498
+
s.Pages.Notice(w, "settings-keys", "Failed to remove public key.")
499
+
return
500
+
}
501
+
} else {
502
+
if err := db.DeletePublicKeyByRkey(s.Db, did, rkey); err != nil {
503
+
log.Printf("removing public key: %s", err)
504
+
s.Pages.Notice(w, "settings-keys", "Failed to remove public key.")
505
+
return
506
+
}
504
507
505
-
if err := db.DeletePublicKey(s.Db, did, name, key); err != nil {
506
-
log.Printf("removing public key: %s", err)
507
-
s.Pages.Notice(w, "settings-keys", "Failed to remove public key.")
508
-
return
509
-
}
508
+
client, err := s.OAuth.AuthorizedClient(r)
509
+
if err != nil {
510
+
log.Printf("failed to authorize client: %s", err)
511
+
s.Pages.Notice(w, "settings-keys", "Failed to authorize client.")
512
+
return
513
+
}
510
514
511
-
if rkey != "" {
512
515
// remove from pds too
513
-
_, err := comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
516
+
_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
514
517
Collection: tangled.PublicKeyNSID,
515
518
Repo: did,
516
519
Rkey: rkey,