commit 203b0a97529c8584bb51d7f43a36502b124d726d · veryroundbird.house/core

+4 -1

knotserver/internal.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
       +
       	"log/slog"

     

       5
       6
        
       	"net/http"

     

       6
       7
        
       

     

       7
       8
        
       	"github.com/go-chi/chi/v5"

     
···

       13
       14
        
       type InternalHandle struct {

     

       14
       15
        
       	db *db.DB

     

       15
       16
        
       	e  *rbac.Enforcer

     

       17
       17
       +
       	l  *slog.Logger

     

       16
       18
        
       }

     

       17
       19
        
       

     

       18
       20
        
       func (h *InternalHandle) PushAllowed(w http.ResponseWriter, r *http.Request) {

     
···

       50
       52
        
       	return

     

       51
       53
        
       }

     

       52
       54
        
       

     

       53
       53
       -
       func Internal(ctx context.Context, db *db.DB, e *rbac.Enforcer) http.Handler {

     

       55
       55
       +
       func Internal(ctx context.Context, db *db.DB, e *rbac.Enforcer, l *slog.Logger) http.Handler {

     

       54
       56
        
       	r := chi.NewRouter()

     

       55
       57
        
       

     

       56
       58
        
       	h := InternalHandle{

     

       57
       59
        
       		db,

     

       58
       60
        
       		e,

     

       61
       61
       +
       		l,

     

       59
       62
        
       	}

     

       60
       63
        
       

     

       61
       64
        
       	r.Get("/push-allowed", h.PushAllowed)

+11 -10

knotserver/server.go

···

       38
       38
        
       }

     

       39
       39
        
       

     

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

     

       41
       41
       -
       	l := log.FromContext(ctx)

     

       41
       41
       +
       	logger := log.FromContext(ctx)

     

       42
       42
       +
       	iLogger := log.New("knotserver/internal")

     

       42
       43
        
       

     

       43
       44
        
       	c, err := config.Load(ctx)

     

       44
       45
        
       	if err != nil {

     
···

       52
       53
        
       	if err != nil {

     

       53
       54
        
       		return fmt.Errorf("failed to setup hooks: %w", err)

     

       54
       55
        
       	}

     

       55
       55
       -
       	l.Info("successfully finished setting up hooks")

     

       56
       56
       +
       	logger.Info("successfully finished setting up hooks")

     

       56
       57
        
       

     

       57
       58
        
       	if c.Server.Dev {

     

       58
       58
       -
       		l.Info("running in dev mode, signature verification is disabled")

     

       59
       59
       +
       		logger.Info("running in dev mode, signature verification is disabled")

     

       59
       60
        
       	}

     

       60
       61
        
       

     

       61
       62
        
       	db, err := db.Setup(c.Server.DBPath)

     
···

       73
       74
        
       	jc, err := jetstream.NewJetstreamClient(c.Server.JetstreamEndpoint, "knotserver", []string{

     

       74
       75
        
       		tangled.PublicKeyNSID,

     

       75
       76
        
       		tangled.KnotMemberNSID,

     

       76
       76
       -
       	}, nil, l, db, true)

     

       77
       77
       +
       	}, nil, logger, db, true)

     

       77
       78
        
       	if err != nil {

     

       78
       78
       -
       		l.Error("failed to setup jetstream", "error", err)

     

       79
       79
       +
       		logger.Error("failed to setup jetstream", "error", err)

     

       79
       80
        
       	}

     

       80
       81
        
       

     

       81
       81
       -
       	mux, err := Setup(ctx, c, db, e, jc, l)

     

       82
       82
       +
       	mux, err := Setup(ctx, c, db, e, jc, logger)

     

       82
       83
        
       	if err != nil {

     

       83
       84
        
       		return fmt.Errorf("failed to setup server: %w", err)

     

       84
       85
        
       	}

     

       85
       85
       -
       	imux := Internal(ctx, db, e)

     

       86
       86
       +
       	imux := Internal(ctx, db, e, iLogger)

     

       86
       87
        
       

     

       87
       87
       -
       	l.Info("starting internal server", "address", c.Server.InternalListenAddr)

     

       88
       88
       +
       	logger.Info("starting internal server", "address", c.Server.InternalListenAddr)

     

       88
       89
        
       	go http.ListenAndServe(c.Server.InternalListenAddr, imux)

     

       89
       90
        
       

     

       90
       90
       -
       	l.Info("starting main server", "address", c.Server.ListenAddr)

     

       91
       91
       -
       	l.Error("server error", "error", http.ListenAndServe(c.Server.ListenAddr, mux))

     

       91
       91
       +
       	logger.Info("starting main server", "address", c.Server.ListenAddr)

     

       92
       92
       +
       	logger.Error("server error", "error", http.ListenAndServe(c.Server.ListenAddr, mux))

     

       92
       93
        
       

     

       93
       94
        
       	return nil

     

       94
       95
        
       }