1package server
2
3import (
4 "context"
5 "errors"
6 "fmt"
7 "net/http"
8
9 "github.com/charmbracelet/log"
10
11 "github.com/charmbracelet/soft-serve/server/backend"
12 "github.com/charmbracelet/soft-serve/server/backend/sqlite"
13 "github.com/charmbracelet/soft-serve/server/config"
14 "github.com/charmbracelet/soft-serve/server/cron"
15 "github.com/charmbracelet/soft-serve/server/daemon"
16 sshsrv "github.com/charmbracelet/soft-serve/server/ssh"
17 "github.com/charmbracelet/soft-serve/server/stats"
18 "github.com/charmbracelet/soft-serve/server/web"
19 "github.com/charmbracelet/ssh"
20 "golang.org/x/sync/errgroup"
21)
22
23// Server is the Soft Serve server.
24type Server struct {
25 SSHServer *sshsrv.SSHServer
26 GitDaemon *daemon.GitDaemon
27 HTTPServer *web.HTTPServer
28 StatsServer *stats.StatsServer
29 Cron *cron.CronScheduler
30 Config *config.Config
31 Backend backend.Backend
32
33 logger *log.Logger
34 ctx context.Context
35}
36
37// NewServer returns a new *ssh.Server configured to serve Soft Serve. The SSH
38// server key-pair will be created if none exists. An initial admin SSH public
39// key can be provided with authKey. If authKey is provided, access will be
40// restricted to that key. If authKey is not provided, the server will be
41// publicly writable until configured otherwise by cloning the `config` repo.
42func NewServer(ctx context.Context) (*Server, error) {
43 cfg := config.FromContext(ctx)
44
45 var err error
46 if cfg.Backend == nil {
47 sb, err := sqlite.NewSqliteBackend(ctx)
48 if err != nil {
49 return nil, fmt.Errorf("create backend: %w", err)
50 }
51
52 cfg = cfg.WithBackend(sb)
53 ctx = backend.WithContext(ctx, sb)
54 }
55
56 srv := &Server{
57 Cron: cron.NewCronScheduler(ctx),
58 Config: cfg,
59 Backend: cfg.Backend,
60 logger: log.FromContext(ctx).WithPrefix("server"),
61 ctx: ctx,
62 }
63
64 // Add cron jobs.
65 _, _ = srv.Cron.AddFunc(jobSpecs["mirror"], srv.mirrorJob())
66
67 srv.SSHServer, err = sshsrv.NewSSHServer(ctx)
68 if err != nil {
69 return nil, fmt.Errorf("create ssh server: %w", err)
70 }
71
72 srv.GitDaemon, err = daemon.NewGitDaemon(ctx)
73 if err != nil {
74 return nil, fmt.Errorf("create git daemon: %w", err)
75 }
76
77 srv.HTTPServer, err = web.NewHTTPServer(ctx)
78 if err != nil {
79 return nil, fmt.Errorf("create http server: %w", err)
80 }
81
82 srv.StatsServer, err = stats.NewStatsServer(ctx)
83 if err != nil {
84 return nil, fmt.Errorf("create stats server: %w", err)
85 }
86
87 return srv, nil
88}
89
90func start(ctx context.Context, fn func() error) error {
91 errc := make(chan error, 1)
92 go func() {
93 errc <- fn()
94 }()
95
96 select {
97 case err := <-errc:
98 return err
99 case <-ctx.Done():
100 return ctx.Err()
101 }
102}
103
104// Start starts the SSH server.
105func (s *Server) Start() error {
106 errg, ctx := errgroup.WithContext(s.ctx)
107 errg.Go(func() error {
108 s.logger.Print("Starting Git daemon", "addr", s.Config.Git.ListenAddr)
109 if err := start(ctx, s.GitDaemon.Start); !errors.Is(err, daemon.ErrServerClosed) {
110 return err
111 }
112 return nil
113 })
114 errg.Go(func() error {
115 s.logger.Print("Starting HTTP server", "addr", s.Config.HTTP.ListenAddr)
116 if err := start(ctx, s.HTTPServer.ListenAndServe); !errors.Is(err, http.ErrServerClosed) {
117 return err
118 }
119 return nil
120 })
121 errg.Go(func() error {
122 s.logger.Print("Starting SSH server", "addr", s.Config.SSH.ListenAddr)
123 if err := start(ctx, s.SSHServer.ListenAndServe); !errors.Is(err, ssh.ErrServerClosed) {
124 return err
125 }
126 return nil
127 })
128 errg.Go(func() error {
129 s.logger.Print("Starting Stats server", "addr", s.Config.Stats.ListenAddr)
130 if err := start(ctx, s.StatsServer.ListenAndServe); !errors.Is(err, http.ErrServerClosed) {
131 return err
132 }
133 return nil
134 })
135 errg.Go(func() error {
136 s.Cron.Start()
137 return nil
138 })
139 return errg.Wait()
140}
141
142// Shutdown lets the server gracefully shutdown.
143func (s *Server) Shutdown(ctx context.Context) error {
144 var errg errgroup.Group
145 errg.Go(func() error {
146 return s.GitDaemon.Shutdown(ctx)
147 })
148 errg.Go(func() error {
149 return s.HTTPServer.Shutdown(ctx)
150 })
151 errg.Go(func() error {
152 return s.SSHServer.Shutdown(ctx)
153 })
154 errg.Go(func() error {
155 return s.StatsServer.Shutdown(ctx)
156 })
157 errg.Go(func() error {
158 s.Cron.Stop()
159 return nil
160 })
161 return errg.Wait()
162}
163
164// Close closes the SSH server.
165func (s *Server) Close() error {
166 var errg errgroup.Group
167 errg.Go(s.GitDaemon.Close)
168 errg.Go(s.HTTPServer.Close)
169 errg.Go(s.SSHServer.Close)
170 errg.Go(s.StatsServer.Close)
171 errg.Go(func() error {
172 s.Cron.Stop()
173 return nil
174 })
175 return errg.Wait()
176}