···

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"context"

     

       
0
       
 
       

     

       
5
       
 
       
	"net/http"

     

       
6
       
 
       


     

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

     
···

       
13
       
 
       
type InternalHandle struct {

     

       
14
       
 
       
	db *db.DB

     

       
15
       
 
       
	e  *rbac.Enforcer

     

       
0
       
 
       

     

       
16
       
 
       
}

     

       
17
       
 
       


     

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

     
···

       
50
       
 
       
	return

     

       
51
       
 
       
}

     

       
52
       
 
       


     

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

     

       
54
       
 
       
	r := chi.NewRouter()

     

       
55
       
 
       


     

       
56
       
 
       
	h := InternalHandle{

     

       
57
       
 
       
		db,

     

       
58
       
 
       
		e,

     

       
0
       
 
       

     

       
59
       
 
       
	}

     

       
60
       
 
       


     

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

     

···

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"context"

     

       
5
       
+
       
	"log/slog"

     

       
6
       
 
       
	"net/http"

     

       
7
       
 
       


     

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

     
···

       
14
       
 
       
type InternalHandle struct {

     

       
15
       
 
       
	db *db.DB

     

       
16
       
 
       
	e  *rbac.Enforcer

     

       
17
       
+
       
	l  *slog.Logger

     

       
18
       
 
       
}

     

       
19
       
 
       


     

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

     
···

       
52
       
 
       
	return

     

       
53
       
 
       
}

     

       
54
       
 
       


     

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

     

       
56
       
 
       
	r := chi.NewRouter()

     

       
57
       
 
       


     

       
58
       
 
       
	h := InternalHandle{

     

       
59
       
 
       
		db,

     

       
60
       
 
       
		e,

     

       
61
       
+
       
		l,

     

       
62
       
 
       
	}

     

       
63
       
 
       


     

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

     

···

       
38
       
 
       
}

     

       
39
       
 
       


     

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

     

       
41
       
-
       
	l := log.FromContext(ctx)

     

       
0
       
 
       

     

       
42
       
 
       


     

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

     

       
44
       
 
       
	if err != nil {

     
···

       
52
       
 
       
	if err != nil {

     

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

     

       
54
       
 
       
	}

     

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

     

       
56
       
 
       


     

       
57
       
 
       
	if c.Server.Dev {

     

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

     

       
59
       
 
       
	}

     

       
60
       
 
       


     

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

     
···

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

     

       
74
       
 
       
		tangled.PublicKeyNSID,

     

       
75
       
 
       
		tangled.KnotMemberNSID,

     

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

     

       
77
       
 
       
	if err != nil {

     

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

     

       
79
       
 
       
	}

     

       
80
       
 
       


     

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

     

       
82
       
 
       
	if err != nil {

     

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

     

       
84
       
 
       
	}

     

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

     

       
86
       
 
       


     

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

     

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

     

       
89
       
 
       


     

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

     

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

     

       
92
       
 
       


     

       
93
       
 
       
	return nil

     

       
94
       
 
       
}

     

···

       
38
       
 
       
}

     

       
39
       
 
       


     

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

     

       
41
       
+
       
	logger := log.FromContext(ctx)

     

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

     

       
43
       
 
       


     

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

     

       
45
       
 
       
	if err != nil {

     
···

       
53
       
 
       
	if err != nil {

     

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

     

       
55
       
 
       
	}

     

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

     

       
57
       
 
       


     

       
58
       
 
       
	if c.Server.Dev {

     

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

     

       
60
       
 
       
	}

     

       
61
       
 
       


     

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

     
···

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

     

       
75
       
 
       
		tangled.PublicKeyNSID,

     

       
76
       
 
       
		tangled.KnotMemberNSID,

     

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

     

       
78
       
 
       
	if err != nil {

     

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

     

       
80
       
 
       
	}

     

       
81
       
 
       


     

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

     

       
83
       
 
       
	if err != nil {

     

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

     

       
85
       
 
       
	}

     

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

     

       
87
       
 
       


     

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

     

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

     

       
90
       
 
       


     

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

     

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

     

       
93
       
 
       


     

       
94
       
 
       
	return nil

     

       
95
       
 
       
}