patch of */config: add PLC URL config option · round #0 · pull #683 · tangled.org/core

+5

appview/config/config.go

···

       28
       28
        
       	Jwks string `env:"JWKS"`

     

       29
       29
        
       }

     

       30
       30
        
       

     

       31
       31
       +
       type PlcConfig struct {

     

       32
       32
       +
       	PLCURL string `env:"URL, default=https://plc.directory"`

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       31
       35
        
       type JetstreamConfig struct {

     

       32
       36
        
       	Endpoint string `env:"ENDPOINT, default=wss://jetstream1.us-east.bsky.network/subscribe"`

     

       33
       37
        
       }

     
···

       103
       107
        
       	Avatar        AvatarConfig    `env:",prefix=TANGLED_AVATAR_"`

     

       104
       108
        
       	OAuth         OAuthConfig     `env:",prefix=TANGLED_OAUTH_"`

     

       105
       109
        
       	Redis         RedisConfig     `env:",prefix=TANGLED_REDIS_"`

     

       110
       110
       +
       	Plc           PlcConfig       `env:",prefix=TANGLED_PLC_"`

     

       106
       111
        
       	Pds           PdsConfig       `env:",prefix=TANGLED_PDS_"`

     

       107
       112
        
       	Cloudflare    Cloudflare      `env:",prefix=TANGLED_CLOUDFLARE_"`

     

       108
       113
        
       }

+2 -2

appview/state/state.go

···

       70
       70
        
       		return nil, fmt.Errorf("failed to create enforcer: %w", err)

     

       71
       71
        
       	}

     

       72
       72
        
       

     

       73
       73
       -
       	res, err := idresolver.RedisResolver(config.Redis.ToURL())

     

       73
       73
       +
       	res, err := idresolver.RedisResolver(config.Redis.ToURL(), config.Plc.PLCURL)

     

       74
       74
        
       	if err != nil {

     

       75
       75
        
       		logger.Error("failed to create redis resolver", "err", err)

     

       76
       76
       -
       		res = idresolver.DefaultResolver()

     

       76
       76
       +
       		res = idresolver.DefaultResolver(config.Plc.PLCURL)

     

       77
       77
        
       	}

     

       78
       78
        
       

     

       79
       79
        
       	posthog, err := posthog.NewWithConfig(config.Posthog.ApiKey, posthog.Config{Endpoint: config.Posthog.Endpoint})

+8 -2

guard/guard.go

···

       17
       17
        
       	"github.com/urfave/cli/v3"

     

       18
       18
        
       	"tangled.org/core/idresolver"

     

       19
       19
        
       	"tangled.org/core/log"

     

       20
       20
       +
       	"tangled.org/core/knotserver/config"

     

       20
       21
        
       )

     

       21
       22
        
       

     

       22
       23
        
       func Command() *cli.Command {

     
···

       57
       58
        
       func Run(ctx context.Context, cmd *cli.Command) error {

     

       58
       59
        
       	l := log.FromContext(ctx)

     

       59
       60
        
       

     

       61
       61
       +
       	c, err := config.Load(ctx)

     

       62
       62
       +
       	if err != nil {

     

       63
       63
       +
       		return fmt.Errorf("failed to load config: %w", err)

     

       64
       64
       +
       	}

     

       65
       65
       +
       

     

       60
       66
        
       	incomingUser := cmd.String("user")

     

       61
       67
        
       	gitDir := cmd.String("git-dir")

     

       62
       68
        
       	logPath := cmd.String("log-path")

     
···

       195
       201
        
       	return nil

     

       196
       202
        
       }

     

       197
       203
        
       

     

       198
       198
       -
       func resolveIdentity(ctx context.Context, l *slog.Logger, didOrHandle string) *identity.Identity {

     

       199
       199
       -
       	resolver := idresolver.DefaultResolver()

     

       204
       204
       +
       func resolveIdentity(ctx context.Context, c *config.Config, l *slog.Logger, didOrHandle string) *identity.Identity {

     

       205
       205
       +
       	resolver := idresolver.DefaultResolver(c.Server.PlcUrl)

     

       200
       206
        
       	ident, err := resolver.ResolveIdent(ctx, didOrHandle)

     

       201
       207
        
       	if err != nil {

     

       202
       208
        
       		l.Error("Error resolving handle", "error", err, "handle", didOrHandle)

+17 -8

idresolver/resolver.go

···

       17
       17
        
       	directory identity.Directory

     

       18
       18
        
       }

     

       19
       19
        
       

     

       20
       20
       -
       func BaseDirectory() identity.Directory {

     

       20
       20
       +
       func BaseDirectory(plcUrl string) identity.Directory {

     

       21
       21
        
       	base := identity.BaseDirectory{

     

       22
       22
       -
       		PLCURL: identity.DefaultPLCURL,

     

       22
       22
       +
       		PLCURL: plcUrl,

     

       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
       45
       -
       func RedisDirectory(url string) (identity.Directory, error) {

     

       45
       45
       +
       func RedisDirectory(url, plcUrl string) (identity.Directory, error) {

     

       46
       46
        
       	hitTTL := time.Hour * 24

     

       47
       47
        
       	errTTL := time.Second * 30

     

       48
       48
        
       	invalidHandleTTL := time.Minute * 5

     

       49
       49
       -
       	return redisdir.NewRedisDirectory(BaseDirectory(), url, hitTTL, errTTL, invalidHandleTTL, 10000)

     

       49
       49
       +
       	return redisdir.NewRedisDirectory(

     

       50
       50
       +
       		BaseDirectory(plcUrl),

     

       51
       51
       +
       		url,

     

       52
       52
       +
       		hitTTL,

     

       53
       53
       +
       		errTTL,

     

       54
       54
       +
       		invalidHandleTTL,

     

       55
       55
       +
       		10000,

     

       56
       56
       +
       	)

     

       50
       57
        
       }

     

       51
       58
        
       

     

       52
       52
       -
       func DefaultResolver() *Resolver {

     

       59
       59
       +
       func DefaultResolver(plcUrl string) *Resolver {

     

       60
       60
       +
       	base := BaseDirectory(plcUrl)

     

       61
       61
       +
       	cached := identity.NewCacheDirectory(base, 250_000, time.Hour*24, time.Minute*2, time.Minute*5)

     

       53
       62
        
       	return &Resolver{

     

       54
       54
       -
       		directory: identity.DefaultDirectory(),

     

       63
       63
       +
       		directory: &cached,

     

       55
       64
        
       	}

     

       56
       65
        
       }

     

       57
       66
        
       

     

       58
       58
       -
       func RedisResolver(redisUrl string) (*Resolver, error) {

     

       59
       59
       -
       	directory, err := RedisDirectory(redisUrl)

     

       67
       67
       +
       func RedisResolver(redisUrl, plcUrl string) (*Resolver, error) {

     

       68
       68
       +
       	directory, err := RedisDirectory(redisUrl, plcUrl)

     

       60
       69
        
       	if err != nil {

     

       61
       70
        
       		return nil, err

     

       62
       71
        
       	}

+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
       22
       +
       	PlcUrl             string `env:"PLC_URL, default=plc.directory"`

     

       22
       23
        
       	JetstreamEndpoint  string `env:"JETSTREAM_ENDPOINT, default=wss://jetstream1.us-west.bsky.network/subscribe"`

     

       23
       24
        
       	Owner              string `env:"OWNER, required"`

     

       24
       25
        
       	LogDids            bool   `env:"LOG_DIDS, default=true"`

+3 -7

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
       19
       -
       	"tangled.org/core/idresolver"

     

       20
       19
        
       	"tangled.org/core/knotserver/db"

     

       21
       20
        
       	"tangled.org/core/knotserver/git"

     

       22
       21
        
       	"tangled.org/core/log"

     
···

       120
       119
        
       	}

     

       121
       120
        
       

     

       122
       121
        
       	// resolve this aturi to extract the repo record

     

       123
       123
       -
       	resolver := idresolver.DefaultResolver()

     

       124
       124
       -
       	ident, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       122
       122
       +
       	ident, err := h.resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       125
       123
        
       	if err != nil || ident.Handle.IsInvalidHandle() {

     

       126
       124
        
       		return fmt.Errorf("failed to resolve handle: %w", err)

     

       127
       125
        
       	}

     
···

       233
       231
        
       		return err

     

       234
       232
        
       	}

     

       235
       233
        
       

     

       236
       236
       -
       	resolver := idresolver.DefaultResolver()

     

       237
       237
       -
       

     

       238
       238
       -
       	subjectId, err := resolver.ResolveIdent(ctx, record.Subject)

     

       234
       234
       +
       	subjectId, err := h.resolver.ResolveIdent(ctx, record.Subject)

     

       239
       235
        
       	if err != nil || subjectId.Handle.IsInvalidHandle() {

     

       240
       236
        
       		return err

     

       241
       237
        
       	}

     

       242
       238
        
       

     

       243
       239
        
       	// TODO: fix this for good, we need to fetch the record here unfortunately

     

       244
       240
        
       	// resolve this aturi to extract the repo record

     

       245
       245
       -
       	owner, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       241
       241
       +
       	owner, err := h.resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       246
       242
        
       	if err != nil || owner.Handle.IsInvalidHandle() {

     

       247
       243
        
       		return fmt.Errorf("failed to resolve handle: %w", err)

     

       248
       244
        
       	}

+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
       148
       -
       	userIdent, err := idresolver.DefaultResolver().ResolveIdent(ctx, repoOwner)

     

       148
       148
       +
       	userIdent, err := idresolver.DefaultResolver(h.c.Server.PlcUrl).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

···

       36
       36
        
       		l:        log.FromContext(ctx),

     

       37
       37
        
       		jc:       jc,

     

       38
       38
        
       		n:        n,

     

       39
       39
       -
       		resolver: idresolver.DefaultResolver(),

     

       39
       39
       +
       		resolver: idresolver.DefaultResolver(c.Server.PlcUrl),

     

       40
       40
        
       	}

     

       41
       41
        
       

     

       42
       42
        
       	err := e.AddKnot(rbac.ThisServer)

+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
       16
       +
       	PlcUrl            string `env:"PLC_URL, default=plc.directory"`

     

       16
       17
        
       	Dev               bool    `env:"DEV, default=false"`

     

       17
       18
        
       	Owner             string  `env:"OWNER, required"`

     

       18
       19
        
       	Secrets           Secrets `env:",prefix=SECRETS_"`

+3 -7

spindle/ingester.go

···

       9
       9
        
       

     

       10
       10
        
       	"tangled.org/core/api/tangled"

     

       11
       11
        
       	"tangled.org/core/eventconsumer"

     

       12
       12
       -
       	"tangled.org/core/idresolver"

     

       13
       12
        
       	"tangled.org/core/rbac"

     

       14
       13
        
       	"tangled.org/core/spindle/db"

     

       15
       14
        
       

     
···

       142
       141
        
       func (s *Spindle) ingestRepo(ctx context.Context, e *models.Event) error {

     

       143
       142
        
       	var err error

     

       144
       143
        
       	did := e.Did

     

       145
       145
       -
       	resolver := idresolver.DefaultResolver()

     

       146
       144
        
       

     

       147
       145
        
       	l := s.l.With("component", "ingester", "record", tangled.RepoNSID)

     

       148
       146
        
       

     
···

       190
       188
        
       		}

     

       191
       189
        
       

     

       192
       190
        
       		// add collaborators to rbac

     

       193
       193
       -
       		owner, err := resolver.ResolveIdent(ctx, did)

     

       191
       191
       +
       		owner, err := s.res.ResolveIdent(ctx, did)

     

       194
       192
        
       		if err != nil || owner.Handle.IsInvalidHandle() {

     

       195
       193
        
       			return err

     

       196
       194
        
       		}

     
···

       225
       223
        
       			return err

     

       226
       224
        
       		}

     

       227
       225
        
       

     

       228
       228
       -
       		resolver := idresolver.DefaultResolver()

     

       229
       229
       -
       

     

       230
       230
       -
       		subjectId, err := resolver.ResolveIdent(ctx, record.Subject)

     

       226
       226
       +
       		subjectId, err := s.res.ResolveIdent(ctx, record.Subject)

     

       231
       227
        
       		if err != nil || subjectId.Handle.IsInvalidHandle() {

     

       232
       228
        
       			return err

     

       233
       229
        
       		}

     
···

       240
       236
        
       

     

       241
       237
        
       		// TODO: get rid of this entirely

     

       242
       238
        
       		// resolve this aturi to extract the repo record

     

       243
       243
       -
       		owner, err := resolver.ResolveIdent(ctx, repoAt.Authority().String())

     

       239
       239
       +
       		owner, err := s.res.ResolveIdent(ctx, repoAt.Authority().String())

     

       244
       240
        
       		if err != nil || owner.Handle.IsInvalidHandle() {

     

       245
       241
        
       			return fmt.Errorf("failed to resolve handle: %w", err)

     

       246
       242
        
       		}

+1 -1

spindle/server.go

···

       123
       123
        
       		jc.AddDid(d)

     

       124
       124
        
       	}

     

       125
       125
        
       

     

       126
       126
       -
       	resolver := idresolver.DefaultResolver()

     

       126
       126
       +
       	resolver := idresolver.DefaultResolver(cfg.Server.PlcUrl)

     

       127
       127
        
       

     

       128
       128
        
       	spindle := Spindle{

     

       129
       129
        
       		jc:    jc,