Monorepo for Tangled
Revert "*/config: add PLC URL config option"
This reverts commit 55812240c5d183e7195d2762e80074062a8c999f.
oppiliappan
(Oct 19, 2025, 12:36 PM +0100)
55b06460
d98e917d
+30
-44
-5
appview/config/config.go
-5
appview/config/config.go
···
28
28
Jwks string `env:"JWKS"`
29
29
}
30
30
31
-
type PlcConfig struct {
32
-
PLCURL string `env:"URL, default=https://plc.directory"`
33
-
}
34
-
35
31
type JetstreamConfig struct {
36
32
Endpoint string `env:"ENDPOINT, default=wss://jetstream1.us-east.bsky.network/subscribe"`
37
33
}
···
107
103
Avatar AvatarConfig `env:",prefix=TANGLED_AVATAR_"`
108
104
OAuth OAuthConfig `env:",prefix=TANGLED_OAUTH_"`
109
105
Redis RedisConfig `env:",prefix=TANGLED_REDIS_"`
110
-
Plc PlcConfig `env:",prefix=TANGLED_PLC_"`
111
106
Pds PdsConfig `env:",prefix=TANGLED_PDS_"`
112
107
Cloudflare Cloudflare `env:",prefix=TANGLED_CLOUDFLARE_"`
113
108
}
+2
-2
appview/state/state.go
+2
-2
appview/state/state.go
···
70
70
return nil, fmt.Errorf("failed to create enforcer: %w", err)
71
71
}
72
72
73
-
res, err := idresolver.RedisResolver(config.Redis.ToURL(), config.Plc.PLCURL)
73
+
res, err := idresolver.RedisResolver(config.Redis.ToURL())
74
74
if err != nil {
75
75
logger.Error("failed to create redis resolver", "err", err)
76
-
res = idresolver.DefaultResolver(config.Plc.PLCURL)
76
+
res = idresolver.DefaultResolver()
77
77
}
78
78
79
79
posthog, err := posthog.NewWithConfig(config.Posthog.ApiKey, posthog.Config{Endpoint: config.Posthog.Endpoint})
+3
-9
guard/guard.go
+3
-9
guard/guard.go
···
16
16
securejoin "github.com/cyphar/filepath-securejoin"
17
17
"github.com/urfave/cli/v3"
18
18
"tangled.org/core/idresolver"
19
-
"tangled.org/core/knotserver/config"
20
19
"tangled.org/core/log"
21
20
)
22
21
···
57
56
58
57
func Run(ctx context.Context, cmd *cli.Command) error {
59
58
l := log.FromContext(ctx)
60
-
61
-
c, err := config.Load(ctx)
62
-
if err != nil {
63
-
return fmt.Errorf("failed to load config: %w", err)
64
-
}
65
59
66
60
incomingUser := cmd.String("user")
67
61
gitDir := cmd.String("git-dir")
···
128
122
}
129
123
130
124
didOrHandle := components[0]
131
-
identity := resolveIdentity(ctx, c, l, didOrHandle)
125
+
identity := resolveIdentity(ctx, l, didOrHandle)
132
126
did := identity.DID.String()
133
127
repoName := components[1]
134
128
qualifiedRepoName, _ := securejoin.SecureJoin(did, repoName)
···
201
195
return nil
202
196
}
203
197
204
-
func resolveIdentity(ctx context.Context, c *config.Config, l *slog.Logger, didOrHandle string) *identity.Identity {
205
-
resolver := idresolver.DefaultResolver(c.Server.PlcUrl)
198
+
func resolveIdentity(ctx context.Context, l *slog.Logger, didOrHandle string) *identity.Identity {
199
+
resolver := idresolver.DefaultResolver()
206
200
ident, err := resolver.ResolveIdent(ctx, didOrHandle)
207
201
if err != nil {
208
202
l.Error("Error resolving handle", "error", err, "handle", didOrHandle)
+8
-17
idresolver/resolver.go
+8
-17
idresolver/resolver.go
···
17
17
directory identity.Directory
18
18
}
19
19
20
-
func BaseDirectory(plcUrl string) identity.Directory {
20
+
func BaseDirectory() identity.Directory {
21
21
base := identity.BaseDirectory{
22
-
PLCURL: plcUrl,
22
+
PLCURL: identity.DefaultPLCURL,
23
23
HTTPClient: http.Client{
24
24
Timeout: time.Second * 10,
25
25
Transport: &http.Transport{
···
42
42
return &base
43
43
}
44
44
45
-
func RedisDirectory(url, plcUrl string) (identity.Directory, error) {
45
+
func RedisDirectory(url string) (identity.Directory, error) {
46
46
hitTTL := time.Hour * 24
47
47
errTTL := time.Second * 30
48
48
invalidHandleTTL := time.Minute * 5
49
-
return redisdir.NewRedisDirectory(
50
-
BaseDirectory(plcUrl),
51
-
url,
52
-
hitTTL,
53
-
errTTL,
54
-
invalidHandleTTL,
55
-
10000,
56
-
)
49
+
return redisdir.NewRedisDirectory(BaseDirectory(), url, hitTTL, errTTL, invalidHandleTTL, 10000)
57
50
}
58
51
59
-
func DefaultResolver(plcUrl string) *Resolver {
60
-
base := BaseDirectory(plcUrl)
61
-
cached := identity.NewCacheDirectory(base, 250_000, time.Hour*24, time.Minute*2, time.Minute*5)
52
+
func DefaultResolver() *Resolver {
62
53
return &Resolver{
63
-
directory: &cached,
54
+
directory: identity.DefaultDirectory(),
64
55
}
65
56
}
66
57
67
-
func RedisResolver(redisUrl, plcUrl string) (*Resolver, error) {
68
-
directory, err := RedisDirectory(redisUrl, plcUrl)
58
+
func RedisResolver(redisUrl string) (*Resolver, error) {
59
+
directory, err := RedisDirectory(redisUrl)
69
60
if err != nil {
70
61
return nil, err
71
62
}
-1
knotserver/config/config.go
-1
knotserver/config/config.go
···
19
19
InternalListenAddr string `env:"INTERNAL_LISTEN_ADDR, default=127.0.0.1:5444"`
20
20
DBPath string `env:"DB_PATH, default=knotserver.db"`
21
21
Hostname string `env:"HOSTNAME, required"`
22
-
PlcUrl string `env:"PLC_URL, default=plc.directory"`
23
22
JetstreamEndpoint string `env:"JETSTREAM_ENDPOINT, default=wss://jetstream1.us-west.bsky.network/subscribe"`
24
23
Owner string `env:"OWNER, required"`
25
24
LogDids bool `env:"LOG_DIDS, default=true"`
+7
-3
knotserver/ingester.go
+7
-3
knotserver/ingester.go
···
16
16
"github.com/bluesky-social/jetstream/pkg/models"
17
17
securejoin "github.com/cyphar/filepath-securejoin"
18
18
"tangled.org/core/api/tangled"
19
+
"tangled.org/core/idresolver"
19
20
"tangled.org/core/knotserver/db"
20
21
"tangled.org/core/knotserver/git"
21
22
"tangled.org/core/log"
···
119
120
}
120
121
121
122
// resolve this aturi to extract the repo record
122
-
ident, err := h.resolver.ResolveIdent(ctx, repoAt.Authority().String())
123
+
resolver := idresolver.DefaultResolver()
124
+
ident, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())
123
125
if err != nil || ident.Handle.IsInvalidHandle() {
124
126
return fmt.Errorf("failed to resolve handle: %w", err)
125
127
}
···
231
233
return err
232
234
}
233
235
234
-
subjectId, err := h.resolver.ResolveIdent(ctx, record.Subject)
236
+
resolver := idresolver.DefaultResolver()
237
+
238
+
subjectId, err := resolver.ResolveIdent(ctx, record.Subject)
235
239
if err != nil || subjectId.Handle.IsInvalidHandle() {
236
240
return err
237
241
}
238
242
239
243
// TODO: fix this for good, we need to fetch the record here unfortunately
240
244
// resolve this aturi to extract the repo record
241
-
owner, err := h.resolver.ResolveIdent(ctx, repoAt.Authority().String())
245
+
owner, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())
242
246
if err != nil || owner.Handle.IsInvalidHandle() {
243
247
return fmt.Errorf("failed to resolve handle: %w", err)
244
248
}
+1
-1
knotserver/internal.go
+1
-1
knotserver/internal.go
···
145
145
146
146
func (h *InternalHandle) replyCompare(line git.PostReceiveLine, repoOwner string, gitRelativeDir string, repoName string, ctx context.Context) ([]string, error) {
147
147
l := h.l.With("handler", "replyCompare")
148
-
userIdent, err := idresolver.DefaultResolver(h.c.Server.PlcUrl).ResolveIdent(ctx, repoOwner)
148
+
userIdent, err := idresolver.DefaultResolver().ResolveIdent(ctx, repoOwner)
149
149
user := repoOwner
150
150
if err != nil {
151
151
l.Error("Failed to fetch user identity", "err", err)
+1
-1
knotserver/router.go
+1
-1
knotserver/router.go
-1
spindle/config/config.go
-1
spindle/config/config.go
···
13
13
DBPath string `env:"DB_PATH, default=spindle.db"`
14
14
Hostname string `env:"HOSTNAME, required"`
15
15
JetstreamEndpoint string `env:"JETSTREAM_ENDPOINT, default=wss://jetstream1.us-west.bsky.network/subscribe"`
16
-
PlcUrl string `env:"PLC_URL, default=plc.directory"`
17
16
Dev bool `env:"DEV, default=false"`
18
17
Owner string `env:"OWNER, required"`
19
18
Secrets Secrets `env:",prefix=SECRETS_"`
+7
-3
spindle/ingester.go
+7
-3
spindle/ingester.go
···
9
9
10
10
"tangled.org/core/api/tangled"
11
11
"tangled.org/core/eventconsumer"
12
+
"tangled.org/core/idresolver"
12
13
"tangled.org/core/rbac"
13
14
"tangled.org/core/spindle/db"
14
15
···
141
142
func (s *Spindle) ingestRepo(ctx context.Context, e *models.Event) error {
142
143
var err error
143
144
did := e.Did
145
+
resolver := idresolver.DefaultResolver()
144
146
145
147
l := s.l.With("component", "ingester", "record", tangled.RepoNSID)
146
148
···
188
190
}
189
191
190
192
// add collaborators to rbac
191
-
owner, err := s.res.ResolveIdent(ctx, did)
193
+
owner, err := resolver.ResolveIdent(ctx, did)
192
194
if err != nil || owner.Handle.IsInvalidHandle() {
193
195
return err
194
196
}
···
223
225
return err
224
226
}
225
227
226
-
subjectId, err := s.res.ResolveIdent(ctx, record.Subject)
228
+
resolver := idresolver.DefaultResolver()
229
+
230
+
subjectId, err := resolver.ResolveIdent(ctx, record.Subject)
227
231
if err != nil || subjectId.Handle.IsInvalidHandle() {
228
232
return err
229
233
}
···
236
240
237
241
// TODO: get rid of this entirely
238
242
// resolve this aturi to extract the repo record
239
-
owner, err := s.res.ResolveIdent(ctx, repoAt.Authority().String())
243
+
owner, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())
240
244
if err != nil || owner.Handle.IsInvalidHandle() {
241
245
return fmt.Errorf("failed to resolve handle: %w", err)
242
246
}