mirror of
https://github.com/usememos/memos.git
synced 2024-09-11 12:05:29 +03:00
163 lines
4.4 KiB
Go
163 lines
4.4 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log/slog"
|
|
"net"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/labstack/echo/v4"
|
|
"github.com/pkg/errors"
|
|
"github.com/soheilhy/cmux"
|
|
"google.golang.org/grpc"
|
|
|
|
storepb "github.com/usememos/memos/proto/gen/store"
|
|
"github.com/usememos/memos/server/profile"
|
|
apiv1 "github.com/usememos/memos/server/router/api/v1"
|
|
"github.com/usememos/memos/server/router/frontend"
|
|
"github.com/usememos/memos/server/router/rss"
|
|
versionchecker "github.com/usememos/memos/server/service/version_checker"
|
|
"github.com/usememos/memos/store"
|
|
)
|
|
|
|
type Server struct {
|
|
Secret string
|
|
Profile *profile.Profile
|
|
Store *store.Store
|
|
|
|
echoServer *echo.Echo
|
|
grpcServer *grpc.Server
|
|
}
|
|
|
|
func NewServer(ctx context.Context, profile *profile.Profile, store *store.Store) (*Server, error) {
|
|
s := &Server{
|
|
Store: store,
|
|
Profile: profile,
|
|
}
|
|
|
|
echoServer := echo.New()
|
|
echoServer.Debug = true
|
|
echoServer.HideBanner = true
|
|
echoServer.HidePort = true
|
|
s.echoServer = echoServer
|
|
|
|
workspaceBasicSetting, err := s.getOrUpsertWorkspaceBasicSetting(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "failed to get workspace basic setting")
|
|
}
|
|
|
|
secret := "usememos"
|
|
if profile.Mode == "prod" {
|
|
secret = workspaceBasicSetting.SecretKey
|
|
}
|
|
s.Secret = secret
|
|
|
|
// Register healthz endpoint.
|
|
echoServer.GET("/healthz", func(c echo.Context) error {
|
|
return c.String(http.StatusOK, "Service ready.")
|
|
})
|
|
|
|
// Only serve frontend when it's enabled.
|
|
if profile.Frontend {
|
|
frontendService := frontend.NewFrontendService(profile, store)
|
|
frontendService.Serve(ctx, echoServer)
|
|
}
|
|
|
|
rootGroup := echoServer.Group("")
|
|
|
|
// Create and register RSS routes.
|
|
rss.NewRSSService(s.Profile, s.Store).RegisterRoutes(rootGroup)
|
|
|
|
grpcServer := grpc.NewServer(grpc.ChainUnaryInterceptor(
|
|
apiv1.NewLoggerInterceptor().LoggerInterceptor,
|
|
apiv1.NewGRPCAuthInterceptor(store, secret).AuthenticationInterceptor,
|
|
))
|
|
s.grpcServer = grpcServer
|
|
|
|
apiV1Service := apiv1.NewAPIV1Service(s.Secret, profile, store, grpcServer)
|
|
// Register gRPC gateway as api v1.
|
|
if err := apiV1Service.RegisterGateway(ctx, echoServer); err != nil {
|
|
return nil, errors.Wrap(err, "failed to register gRPC gateway")
|
|
}
|
|
|
|
return s, nil
|
|
}
|
|
|
|
func (s *Server) Start(ctx context.Context) error {
|
|
address := fmt.Sprintf(":%d", s.Profile.Port)
|
|
listener, err := net.Listen("tcp", address)
|
|
if err != nil {
|
|
return errors.Wrap(err, "failed to listen")
|
|
}
|
|
|
|
muxServer := cmux.New(listener)
|
|
go func() {
|
|
grpcListener := muxServer.MatchWithWriters(cmux.HTTP2MatchHeaderFieldSendSettings("content-type", "application/grpc"))
|
|
if err := s.grpcServer.Serve(grpcListener); err != nil {
|
|
slog.Error("failed to serve gRPC", err)
|
|
}
|
|
}()
|
|
go func() {
|
|
httpListener := muxServer.Match(cmux.HTTP1Fast())
|
|
s.echoServer.Listener = httpListener
|
|
if err := s.echoServer.Start(address); err != nil {
|
|
slog.Error("failed to start echo server", err)
|
|
}
|
|
}()
|
|
go func() {
|
|
if err := muxServer.Serve(); err != nil {
|
|
slog.Error("mux server listen error", err)
|
|
}
|
|
}()
|
|
s.StartBackgroundRunners(ctx)
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Server) Shutdown(ctx context.Context) {
|
|
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
|
|
defer cancel()
|
|
|
|
// Shutdown echo server.
|
|
if err := s.echoServer.Shutdown(ctx); err != nil {
|
|
fmt.Printf("failed to shutdown server, error: %v\n", err)
|
|
}
|
|
|
|
// Close database connection.
|
|
if err := s.Store.Close(); err != nil {
|
|
fmt.Printf("failed to close database, error: %v\n", err)
|
|
}
|
|
|
|
fmt.Printf("memos stopped properly\n")
|
|
}
|
|
|
|
func (s *Server) StartBackgroundRunners(ctx context.Context) {
|
|
go versionchecker.NewVersionChecker(s.Store, s.Profile).Start(ctx)
|
|
}
|
|
|
|
func (s *Server) getOrUpsertWorkspaceBasicSetting(ctx context.Context) (*storepb.WorkspaceBasicSetting, error) {
|
|
workspaceBasicSetting, err := s.Store.GetWorkspaceBasicSetting(ctx)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "failed to get workspace basic setting")
|
|
}
|
|
modified := false
|
|
if workspaceBasicSetting.SecretKey == "" {
|
|
workspaceBasicSetting.SecretKey = uuid.NewString()
|
|
modified = true
|
|
}
|
|
if modified {
|
|
workspaceSetting, err := s.Store.UpsertWorkspaceSetting(ctx, &storepb.WorkspaceSetting{
|
|
Key: storepb.WorkspaceSettingKey_WORKSPACE_SETTING_BASIC,
|
|
Value: &storepb.WorkspaceSetting_BasicSetting{BasicSetting: workspaceBasicSetting},
|
|
})
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "failed to upsert workspace setting")
|
|
}
|
|
workspaceBasicSetting = workspaceSetting.GetBasicSetting()
|
|
}
|
|
return workspaceBasicSetting, nil
|
|
}
|