neko/server/internal/api/router.go at 47ee72c19ae7e971de39942a4485234d18e9bcf3 · kernel/neko · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
package api

import (
	"context"
	"errors"
	"net/http"

	"github.com/m1k1o/neko/server/internal/api/benchmark"
	"github.com/m1k1o/neko/server/internal/api/members"
	"github.com/m1k1o/neko/server/internal/api/room"
	"github.com/m1k1o/neko/server/internal/api/sessions"
	"github.com/m1k1o/neko/server/internal/benchmarks"
	"github.com/m1k1o/neko/server/pkg/auth"
	"github.com/m1k1o/neko/server/pkg/types"
	"github.com/m1k1o/neko/server/pkg/utils"
)

type ApiManagerCtx struct {
	sessions          types.SessionManager
	members           types.MemberManager
	desktop           types.DesktopManager
	capture           types.CaptureManager
	benchmarkCollector *benchmarks.WebRTCStatsCollector
	routers           map[string]func(types.Router)
}

func New(
	sessions types.SessionManager,
	members types.MemberManager,
	desktop types.DesktopManager,
	capture types.CaptureManager,
	benchmarkCollector *benchmarks.WebRTCStatsCollector,
) *ApiManagerCtx {

	return &ApiManagerCtx{
		sessions:          sessions,
		members:           members,
		desktop:           desktop,
		capture:           capture,
		benchmarkCollector: benchmarkCollector,
		routers:           make(map[string]func(types.Router)),
	}
}

func (api *ApiManagerCtx) Route(r types.Router) {
	r.Post("/login", api.Login)

	// Internal benchmark endpoint (unauthenticated)
	if api.benchmarkCollector != nil {
		benchmarkHandler := benchmark.New(api.benchmarkCollector)
		r.Route("/internal/benchmark", benchmarkHandler.Route)
	}

	// Authenticated area
	r.Group(func(r types.Router) {
		r.Use(api.Authenticate)

		r.Post("/logout", api.Logout)
		r.Get("/whoami", api.Whoami)
		r.Post("/profile", api.UpdateProfile)
		r.Get("/stats", api.Stats)

		sessionsHandler := sessions.New(api.sessions)
		r.Route("/sessions", sessionsHandler.Route)

		membersHandler := members.New(api.members)
		r.Route("/members", membersHandler.Route)
		r.Route("/members_bulk", membersHandler.RouteBulk)

		roomHandler := room.New(api.sessions, api.desktop, api.capture)
		r.Route("/room", roomHandler.Route)

		for path, router := range api.routers {
			r.Route(path, router)
		}
	})
}

func (api *ApiManagerCtx) Authenticate(w http.ResponseWriter, r *http.Request) (context.Context, error) {
	session, err := api.sessions.Authenticate(r)
	if err != nil {
		if api.sessions.CookieEnabled() {
			api.sessions.CookieClearToken(w, r)
		}

		if errors.Is(err, types.ErrSessionLoginDisabled) {
			return nil, utils.HttpForbidden("login is disabled for this session")
		}

		return nil, utils.HttpUnauthorized().WithInternalErr(err)
	}

	return auth.SetSession(r, session), nil
}

func (api *ApiManagerCtx) AddRouter(path string, router func(types.Router)) {
	api.routers[path] = router
}