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
···
418
417
log.Println("unimplemented")
419
418
return
420
419
case http.MethodPut:
421
-
did := s.OAuth.GetDid(r)
422
-
key := r.FormValue("key")
423
-
key = strings.TrimSpace(key)
424
-
name := r.FormValue("name")
425
-
client, err := s.OAuth.AuthorizedClient(r)
426
-
if err != nil {
427
-
s.Pages.Notice(w, "settings-keys", "Failed to authorize. Try again later.")
428
-
return
420
+
created := time.Now()
421
+
pubKey := models.PublicKey{
422
+
Did: s.OAuth.GetDid(r),
423
+
Rkey: tid.TID(),
424
+
Name: r.FormValue("name"),
425
+
Key: strings.TrimSpace(r.FormValue("key")),
426
+
Created: &created,
429
427
}
430
428
431
-
_, _, _, _, err = ssh.ParseAuthorizedKey([]byte(key))
432
-
if err != nil {
429
+
if err := pubKey.Validate(); err != nil {
433
430
log.Printf("parsing public key: %s", err)
434
431
s.Pages.Notice(w, "settings-keys", "That doesn't look like a valid public key. Make sure it's a <strong>public</strong> key.")
435
432
return
436
433
}
437
434
438
-
rkey := tid.TID()
439
-
440
435
tx, err := s.Db.Begin()
441
436
if err != nil {
442
437
log.Printf("failed to start tx; adding public key: %s", err)
···
445
440
}
446
441
defer tx.Rollback()
447
442
448
-
if err := db.AddPublicKey(tx, did, name, key, rkey); err != nil {
443
+
if err = db.UpsertPublicKey(s.Db, pubKey); err != nil {
449
444
log.Printf("adding public key: %s", err)
450
445
s.Pages.Notice(w, "settings-keys", "Failed to add public key.")
446
+
return
447
+
}
448
+
449
+
client, err := s.OAuth.AuthorizedClient(r)
450
+
if err != nil {
451
+
s.Pages.Notice(w, "settings-keys", "Failed to authorize. Try again later.")
451
452
return
452
453
}
453
454
454
455
// store in pds too
456
+
record := pubKey.AsRecord()
455
457
resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{
456
458
Collection: tangled.PublicKeyNSID,
457
-
Repo: did,
458
-
Rkey: rkey,
459
+
Repo: pubKey.Did,
460
+
Rkey: pubKey.Rkey,
459
461
Record: &lexutil.LexiconTypeDecoder{
460
-
Val: &tangled.PublicKey{
461
-
CreatedAt: time.Now().Format(time.RFC3339),
462
-
Key: key,
463
-
Name: name,
464
-
}},
462
+
Val: &record,
463
+
},
465
464
})
466
465
// invalid record
467
466
if err != nil {
···
488
487
489
488
name := q.Get("name")
490
489
rkey := q.Get("rkey")
491
-
key := q.Get("key")
492
490
493
491
log.Println(name)
494
492
log.Println(rkey)
495
-
log.Println(key)
496
493
497
-
client, err := s.OAuth.AuthorizedClient(r)
498
-
if err != nil {
499
-
log.Printf("failed to authorize client: %s", err)
500
-
s.Pages.Notice(w, "settings-keys", "Failed to authorize client.")
501
-
return
502
-
}
494
+
if rkey == "" {
495
+
if err := db.DeletePublicKeyLegacy(s.Db, did, name); err != nil {
496
+
log.Printf("removing public key: %s", err)
497
+
s.Pages.Notice(w, "settings-keys", "Failed to remove public key.")
498
+
return
499
+
}
500
+
} else {
501
+
if err := db.DeletePublicKeyByRkey(s.Db, did, rkey); err != nil {
502
+
log.Printf("removing public key: %s", err)
503
+
s.Pages.Notice(w, "settings-keys", "Failed to remove public key.")
504
+
return
505
+
}
503
506
504
-
if err := db.DeletePublicKey(s.Db, did, name, key); err != nil {
505
-
log.Printf("removing public key: %s", err)
506
-
s.Pages.Notice(w, "settings-keys", "Failed to remove public key.")
507
-
return
508
-
}
507
+
client, err := s.OAuth.AuthorizedClient(r)
508
+
if err != nil {
509
+
log.Printf("failed to authorize client: %s", err)
510
+
s.Pages.Notice(w, "settings-keys", "Failed to authorize client.")
511
+
return
512
+
}
509
513
510
-
if rkey != "" {
511
514
// remove from pds too
512
-
_, err := comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
515
+
_, err = comatproto.RepoDeleteRecord(r.Context(), client, &comatproto.RepoDeleteRecord_Input{
513
516
Collection: tangled.PublicKeyNSID,
514
517
Repo: did,
515
518
Rkey: rkey,