mirror of
https://github.com/renorris/openfsd
synced 2026-03-22 23:05:36 +08:00
57d54d6705
Changes:
- Implement bootstrapping library for managing several concurrent internal services
- Refactor concurrency model for connections/logical clients and their associated I/O
- Refactor server context singleton
- Refactor error handling
- Most errors are now gracefully sent to the FSD client directly encoded as an $ER packet,
enhancing visibility and debugging
- Most errors are now rightfully treated as non-fatal
- Refactor package/dependency graph
- Refactor calling conventions/interfaces for many packages
- Refactor database package
- Refactor post office
Features:
- Add VATSIM-esque HTTP/JSON "data feed"
- Add ephemeral in-memory database option
- Add user management REST API
- Add improved web interface
- Add MySQL support (drop SQLite support)
70 lines
1.7 KiB
Go
70 lines
1.7 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
sqle "github.com/dolthub/go-mysql-server"
|
|
"github.com/dolthub/go-mysql-server/memory"
|
|
"github.com/dolthub/go-mysql-server/server"
|
|
"github.com/fatih/color"
|
|
"github.com/renorris/openfsd/database"
|
|
"github.com/renorris/openfsd/servercontext"
|
|
"log"
|
|
"net"
|
|
)
|
|
|
|
type InMemoryDatabaseService struct{}
|
|
|
|
func (s *InMemoryDatabaseService) Start(ctx context.Context, doneErr chan<- error) error {
|
|
ready := make(chan struct{})
|
|
|
|
go func(ctx context.Context, doneErr chan<- error, ready chan struct{}) {
|
|
doneErr <- s.boot(ctx, ready)
|
|
}(ctx, doneErr, ready)
|
|
|
|
// wait for ready signal
|
|
<-ready
|
|
|
|
// Initialize database
|
|
return database.Initialize(servercontext.DB())
|
|
}
|
|
|
|
func (s *InMemoryDatabaseService) boot(ctx context.Context, ready chan struct{}) (err error) {
|
|
db := memory.NewDatabase("openfsd")
|
|
db.BaseDatabase.EnablePrimaryKeyIndexes()
|
|
|
|
pro := memory.NewDBProvider(db)
|
|
engine := sqle.NewDefault(pro)
|
|
|
|
var listener net.Listener
|
|
if listener, err = net.Listen("tcp", "127.0.0.1:33060"); err != nil {
|
|
close(ready)
|
|
return err
|
|
}
|
|
|
|
close(ready)
|
|
|
|
config := server.Config{
|
|
Protocol: "tcp",
|
|
Listener: listener,
|
|
}
|
|
|
|
log.Println(color.YellowString("WARNING: ") + "using an ephemeral in-memory database. This should only be used for testing. All data will be lost when the process ends.")
|
|
log.Printf("In-memory MySQL server listening on 127.0.0.1:33060")
|
|
defer log.Println("In-memory MySQL server shutting down...")
|
|
|
|
var srv *server.Server
|
|
if srv, err = server.NewServer(config, engine, memory.NewSessionBuilder(pro), nil); err != nil {
|
|
return err
|
|
}
|
|
|
|
errCh := make(chan error)
|
|
go func() { errCh <- srv.Start() }()
|
|
|
|
select {
|
|
case <-ctx.Done():
|
|
return srv.Close()
|
|
case err = <-errCh:
|
|
return err
|
|
}
|
|
}
|