799 lines
26 KiB
Go
799 lines
26 KiB
Go
package main
|
|
|
|
import (
|
|
library "git.ailur.dev/ailur/fg-library/v2"
|
|
|
|
"errors"
|
|
"io"
|
|
"io/fs"
|
|
"log"
|
|
"os"
|
|
"plugin"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"compress/gzip"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"log/slog"
|
|
"net/http"
|
|
"path/filepath"
|
|
|
|
"github.com/andybalholm/brotli"
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/go-chi/hostrouter"
|
|
"github.com/go-playground/validator/v10"
|
|
"github.com/google/uuid"
|
|
"github.com/klauspost/compress/zstd"
|
|
|
|
_ "github.com/lib/pq"
|
|
_ "github.com/mattn/go-sqlite3"
|
|
)
|
|
|
|
type Config struct {
|
|
Global struct {
|
|
IP string `json:"ip" validate:"required,ip_addr"`
|
|
Port string `json:"port" validate:"required"`
|
|
ServiceDirectory string `json:"serviceDirectory" validate:"required"`
|
|
ResourceDirectory string `json:"resourceDirectory" validate:"required"`
|
|
Compression string `json:"compression" validate:"omitempty,oneof=gzip brotli zstd"`
|
|
CompressionLevelJN json.Number `json:"compressionLevel" validate:"required_with=Compression"`
|
|
CompressionLevel int
|
|
} `json:"global" validate:"required"`
|
|
Logging struct {
|
|
Enabled bool `json:"enabled"`
|
|
File string `json:"file" validate:"required_if=Enabled true"`
|
|
} `json:"logging"`
|
|
Database struct {
|
|
DatabaseType string `json:"databaseType" validate:"required,oneof=sqlite postgres"`
|
|
ConnectionString string `json:"connectionString" validate:"required_if=DatabaseType postgres"`
|
|
DatabasePath string `json:"databasePath" validate:"required_if=DatabaseType sqlite"`
|
|
} `json:"database" validate:"required"`
|
|
Static []struct {
|
|
Subdomain string `json:"subdomain"`
|
|
Directory string `json:"directory" validate:"required,isDirectory"`
|
|
Pattern string `json:"pattern"`
|
|
} `json:"static"`
|
|
Services map[string]interface{} `json:"services"`
|
|
}
|
|
|
|
type Service struct {
|
|
ServiceID uuid.UUID
|
|
ServiceMetadata library.Service
|
|
Inbox chan library.InterServiceMessage
|
|
}
|
|
|
|
type ResponseWriterWrapper struct {
|
|
http.ResponseWriter
|
|
io.Writer
|
|
}
|
|
|
|
func (w *ResponseWriterWrapper) WriteHeader(statusCode int) {
|
|
w.ResponseWriter.WriteHeader(statusCode)
|
|
}
|
|
|
|
func (w *ResponseWriterWrapper) Write(p []byte) (int, error) {
|
|
return w.Writer.Write(p)
|
|
}
|
|
|
|
var (
|
|
logger = func(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
next.ServeHTTP(w, r)
|
|
slog.Info(r.Method + " " + r.URL.Path)
|
|
})
|
|
}
|
|
serverChanger = func(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Server", "Fulgens HTTP Server")
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
}
|
|
gzipHandler = func(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
|
|
gzipWriter, err := gzip.NewWriterLevel(w, config.Global.CompressionLevel)
|
|
if err != nil {
|
|
slog.Error("Error creating gzip writer: ", err)
|
|
next.ServeHTTP(w, r)
|
|
return
|
|
}
|
|
if w.Header().Get("Content-Encoding") != "" {
|
|
w.Header().Set("Content-Encoding", w.Header().Get("Content-Encoding")+", gzip")
|
|
} else {
|
|
w.Header().Set("Content-Encoding", "gzip")
|
|
}
|
|
defer func() {
|
|
w.Header().Del("Content-Length")
|
|
err := gzipWriter.Close()
|
|
if errors.Is(err, http.ErrBodyNotAllowed) {
|
|
// This is fine, all it means is that they have it cached, and we don't need to send it
|
|
return
|
|
} else if err != nil {
|
|
slog.Error("Error closing gzip writer: ", err)
|
|
}
|
|
}()
|
|
gzipResponseWriter := &ResponseWriterWrapper{ResponseWriter: w, Writer: gzipWriter}
|
|
next.ServeHTTP(gzipResponseWriter, r)
|
|
} else {
|
|
next.ServeHTTP(w, r)
|
|
}
|
|
})
|
|
}
|
|
brotliHandler = func(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if strings.Contains(r.Header.Get("Accept-Encoding"), "br") {
|
|
brotliWriter := brotli.NewWriterV2(w, config.Global.CompressionLevel)
|
|
if w.Header().Get("Content-Encoding") != "" {
|
|
w.Header().Set("Content-Encoding", w.Header().Get("Content-Encoding")+", br")
|
|
} else {
|
|
w.Header().Set("Content-Encoding", "br")
|
|
}
|
|
defer func() {
|
|
w.Header().Del("Content-Length")
|
|
err := brotliWriter.Close()
|
|
if errors.Is(err, http.ErrBodyNotAllowed) {
|
|
// This is fine, all it means is that they have it cached, and we don't need to send it
|
|
return
|
|
} else if err != nil {
|
|
slog.Error("Error closing Brotli writer: ", err)
|
|
}
|
|
}()
|
|
brotliResponseWriter := &ResponseWriterWrapper{ResponseWriter: w, Writer: brotliWriter}
|
|
next.ServeHTTP(brotliResponseWriter, r)
|
|
} else {
|
|
next.ServeHTTP(w, r)
|
|
}
|
|
})
|
|
}
|
|
zStandardHandler = func(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if strings.Contains(r.Header.Get("Accept-Encoding"), "zstd") {
|
|
zStandardWriter, err := zstd.NewWriter(w, zstd.WithEncoderLevel(zstd.EncoderLevelFromZstd(config.Global.CompressionLevel)))
|
|
if err != nil {
|
|
slog.Error("Error creating ZStandard writer: ", err)
|
|
next.ServeHTTP(w, r)
|
|
return
|
|
}
|
|
if w.Header().Get("Content-Encoding") != "" {
|
|
w.Header().Set("Content-Encoding", w.Header().Get("Content-Encoding")+", zstd")
|
|
} else {
|
|
w.Header().Set("Content-Encoding", "zstd")
|
|
}
|
|
defer func() {
|
|
w.Header().Del("Content-Length")
|
|
err := zStandardWriter.Close()
|
|
if err != nil {
|
|
if errors.Is(err, http.ErrBodyNotAllowed) {
|
|
// This is fine, all it means is that they have it cached, and we don't need to send it
|
|
return
|
|
} else {
|
|
slog.Error("Error closing ZStandard writer: ", err)
|
|
}
|
|
}
|
|
}()
|
|
gzipResponseWriter := &ResponseWriterWrapper{ResponseWriter: w, Writer: zStandardWriter}
|
|
next.ServeHTTP(gzipResponseWriter, r)
|
|
} else {
|
|
next.ServeHTTP(w, r)
|
|
}
|
|
})
|
|
}
|
|
validate *validator.Validate
|
|
services = make(map[uuid.UUID]Service)
|
|
lock sync.RWMutex
|
|
hostRouter = hostrouter.New()
|
|
config Config
|
|
)
|
|
|
|
func processInterServiceMessage(channel chan library.InterServiceMessage) {
|
|
for {
|
|
message := <-channel
|
|
if message.ForServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000000") {
|
|
// Broadcast message
|
|
for _, service := range services {
|
|
service.Inbox <- message
|
|
}
|
|
} else if message.ForServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000001") {
|
|
// Service initialization service
|
|
switch message.MessageType {
|
|
case 0:
|
|
// This has been deprecated, ignore it
|
|
// Send "true" back
|
|
services[message.ServiceID].Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 0,
|
|
SentAt: time.Now(),
|
|
Message: true,
|
|
}
|
|
case 1:
|
|
// Service database initialization message
|
|
// Check if the service has the necessary permissions
|
|
if services[message.ServiceID].ServiceMetadata.Permissions.Database {
|
|
// Check if we are using sqlite or postgres
|
|
if config.Database.DatabaseType == "sqlite" {
|
|
// Open the database and return the connection
|
|
pluginConn, err := sql.Open("sqlite3", filepath.Join(config.Database.DatabasePath, message.ServiceID.String()+".db"))
|
|
if err != nil {
|
|
// Report an error
|
|
services[message.ServiceID].Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: err,
|
|
}
|
|
} else {
|
|
// Report a successful activation
|
|
services[message.ServiceID].Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 2,
|
|
SentAt: time.Now(),
|
|
Message: library.Database{
|
|
DB: pluginConn,
|
|
DBType: library.Sqlite,
|
|
},
|
|
}
|
|
}
|
|
} else if config.Database.DatabaseType == "postgres" {
|
|
// Connect to the database
|
|
conn, err := sql.Open("postgres", config.Database.ConnectionString)
|
|
if err != nil {
|
|
// Report an error
|
|
services[message.ServiceID].Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: err,
|
|
}
|
|
} else {
|
|
// Try to create the schema
|
|
_, err = conn.Exec("CREATE SCHEMA IF NOT EXISTS \"" + message.ServiceID.String() + "\"")
|
|
if err != nil {
|
|
// Report an error
|
|
services[message.ServiceID].Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: err,
|
|
}
|
|
} else {
|
|
// Create a new connection to the database
|
|
var connectionString string
|
|
if strings.Contains(config.Database.ConnectionString, "?") {
|
|
connectionString = config.Database.ConnectionString + "&search_path=\"" + message.ServiceID.String() + "\""
|
|
} else {
|
|
connectionString = config.Database.ConnectionString + "?search_path=\"" + message.ServiceID.String() + "\""
|
|
}
|
|
pluginConn, err := sql.Open("postgres", connectionString)
|
|
if err != nil {
|
|
// Report an error
|
|
services[message.ServiceID].Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: err,
|
|
}
|
|
} else {
|
|
// Test the connection
|
|
err = pluginConn.Ping()
|
|
if err != nil {
|
|
// Report an error
|
|
services[message.ServiceID].Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: err,
|
|
}
|
|
} else {
|
|
// Report a successful activation
|
|
services[message.ServiceID].Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 2,
|
|
SentAt: time.Now(),
|
|
Message: library.Database{
|
|
DB: pluginConn,
|
|
DBType: library.Postgres,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Report an error
|
|
services[message.ServiceID].Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: errors.New("database access not permitted"),
|
|
}
|
|
}
|
|
}
|
|
} else if message.ForServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000002") {
|
|
// Logger service
|
|
service, ok := services[message.ServiceID]
|
|
if ok {
|
|
switch message.MessageType {
|
|
case 0:
|
|
// Log message
|
|
slog.Info(service.ServiceMetadata.Name + " says: " + message.Message.(string))
|
|
case 1:
|
|
// Warn message
|
|
slog.Warn(service.ServiceMetadata.Name + " warns: " + message.Message.(string))
|
|
case 2:
|
|
// Error message
|
|
slog.Error(service.ServiceMetadata.Name + " complains: " + message.Message.(string))
|
|
case 3:
|
|
// Fatal message
|
|
slog.Error(service.ServiceMetadata.Name + "'s dying wish: " + message.Message.(string))
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
} else if message.ForServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000003") {
|
|
// We need to check if the service is allowed to access the Blob Storage service
|
|
serviceMetadata, ok := services[message.ServiceID]
|
|
if ok && serviceMetadata.ServiceMetadata.Permissions.BlobStorage {
|
|
// Send message to Blob Storage service
|
|
service, ok := services[uuid.MustParse("00000000-0000-0000-0000-000000000003")]
|
|
if ok {
|
|
service.Inbox <- message
|
|
} else if !ok {
|
|
// Send error message
|
|
service, ok := services[message.ServiceID]
|
|
if ok {
|
|
service.Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: errors.New("blob storage service not found"),
|
|
}
|
|
} else {
|
|
// This should never happen
|
|
slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
|
|
os.Exit(1)
|
|
}
|
|
} else {
|
|
// Send error message
|
|
service, ok := services[message.ServiceID]
|
|
if ok {
|
|
service.Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: errors.New("blob storage is not yet available"),
|
|
}
|
|
} else {
|
|
// This should never happen
|
|
slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
} else {
|
|
// Send error message
|
|
service, ok := services[message.ServiceID]
|
|
if ok {
|
|
service.Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: errors.New("blob storage is not permitted"),
|
|
}
|
|
} else {
|
|
// This should never happen
|
|
slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
} else if message.ForServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000004") {
|
|
// We need to check if the service is allowed to access the Authentication service
|
|
serviceMetadata, ok := services[message.ServiceID]
|
|
if ok && serviceMetadata.ServiceMetadata.Permissions.Authenticate {
|
|
// Send message to Authentication service
|
|
service, ok := services[uuid.MustParse("00000000-0000-0000-0000-000000000004")]
|
|
if ok {
|
|
service.Inbox <- message
|
|
} else if !ok {
|
|
// Send error message
|
|
service, ok := services[message.ServiceID]
|
|
if ok {
|
|
service.Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: errors.New("authentication service not found"),
|
|
}
|
|
} else {
|
|
// This should never happen
|
|
slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
|
|
os.Exit(1)
|
|
}
|
|
} else {
|
|
// Send error message
|
|
service, ok := services[message.ServiceID]
|
|
if ok {
|
|
service.Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: errors.New("authentication service not yet available"),
|
|
}
|
|
} else {
|
|
// This should never happen
|
|
slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
} else {
|
|
// Send error message
|
|
service, ok := services[message.ServiceID]
|
|
if ok {
|
|
service.Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: errors.New("authentication not permitted"),
|
|
}
|
|
} else {
|
|
// This should never happen
|
|
slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
} else {
|
|
serviceMetadata, ok := services[message.ServiceID]
|
|
if ok && serviceMetadata.ServiceMetadata.Permissions.InterServiceCommunication {
|
|
// Send message to specific service
|
|
service, ok := services[message.ForServiceID]
|
|
if !ok {
|
|
// Send error message
|
|
service, ok := services[message.ServiceID]
|
|
if ok {
|
|
service.Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: errors.New("requested service not found"),
|
|
}
|
|
} else {
|
|
// This should never happen
|
|
slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
service.Inbox <- message
|
|
} else {
|
|
// Send error message
|
|
service, ok := services[message.ServiceID]
|
|
if ok {
|
|
service.Inbox <- library.InterServiceMessage{
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"),
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 1,
|
|
SentAt: time.Now(),
|
|
Message: errors.New("inter-service communication not permitted"),
|
|
}
|
|
} else {
|
|
// This should never happen
|
|
slog.Error("Bit flip error: Impossible service ID. Move away from radiation or use ECC memory.")
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseConfig(path string) Config {
|
|
// Register the custom validators
|
|
validate = validator.New()
|
|
|
|
// Register the custom isDirectory validator
|
|
err := validate.RegisterValidation("isDirectory", func(fl validator.FieldLevel) bool {
|
|
// Check if it exists
|
|
fileInfo, err := os.Stat(fl.Field().String())
|
|
if err != nil {
|
|
return false
|
|
}
|
|
|
|
// Check if it is a directory
|
|
return fileInfo.IsDir()
|
|
})
|
|
if err != nil {
|
|
slog.Error("Error registering custom validator: ", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Parse the configuration file
|
|
configFile, err := os.Open(path)
|
|
if err != nil {
|
|
slog.Error("Error reading configuration file: ", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Parse the configuration file
|
|
var config Config
|
|
decoder := json.NewDecoder(configFile)
|
|
decoder.UseNumber()
|
|
err = decoder.Decode(&config)
|
|
if err != nil {
|
|
slog.Error("Error parsing configuration file: ", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Set the compression level
|
|
if config.Global.Compression != "" {
|
|
compressionLevelI64, err := config.Global.CompressionLevelJN.Int64()
|
|
if err != nil {
|
|
slog.Error("Error parsing compression level: ", err)
|
|
os.Exit(1)
|
|
}
|
|
config.Global.CompressionLevel = int(compressionLevelI64)
|
|
}
|
|
|
|
// Validate the configuration
|
|
err = validate.Struct(config)
|
|
if err != nil {
|
|
slog.Error("Invalid configuration: ", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Check if we are logging to a file
|
|
if config.Logging != (Config{}.Logging) && config.Logging.Enabled {
|
|
// Check if the log file is set
|
|
logFilePath := config.Logging.File
|
|
|
|
// Set the log file
|
|
logFile, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
|
|
if err != nil {
|
|
slog.Error("Error opening log file: ", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
log.SetOutput(io.MultiWriter(os.Stdout, logFile))
|
|
}
|
|
|
|
return config
|
|
}
|
|
|
|
func main() {
|
|
// Parse the configuration file
|
|
if len(os.Args) < 2 {
|
|
info, err := os.Stat("config.json")
|
|
if err != nil {
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
slog.Error("No configuration file provided")
|
|
os.Exit(1)
|
|
} else {
|
|
slog.Error("Error reading configuration file: ", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
if info.IsDir() {
|
|
slog.Error("No configuration file provided")
|
|
os.Exit(1)
|
|
}
|
|
|
|
config = parseConfig("config.json")
|
|
} else {
|
|
config = parseConfig(os.Args[1])
|
|
}
|
|
|
|
// If we are using sqlite, create the database directory if it does not exist
|
|
if config.Database.DatabaseType == "sqlite" {
|
|
err := os.MkdirAll(config.Database.DatabasePath, 0755)
|
|
if err != nil {
|
|
slog.Error("Error creating database directory: ", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
// Create the router
|
|
router := chi.NewRouter()
|
|
router.Use(logger)
|
|
router.Use(serverChanger)
|
|
|
|
// Iterate through the service configurations and create routers for each unique subdomain
|
|
subdomains := make(map[string]*chi.Mux)
|
|
for _, service := range config.Services {
|
|
if service.(map[string]interface{})["subdomain"] != nil {
|
|
subdomain := service.(map[string]interface{})["subdomain"].(string)
|
|
if subdomains[subdomain] == nil {
|
|
subdomains[subdomain] = chi.NewRouter()
|
|
slog.Info("Mapping subdomain " + subdomain)
|
|
hostRouter.Map(subdomain, subdomains[subdomain])
|
|
}
|
|
}
|
|
}
|
|
|
|
// Iterate through the static configurations and create routers for each unique subdomain
|
|
for _, static := range config.Static {
|
|
// Check if it wants a subdomain
|
|
if static.Subdomain != "" {
|
|
// Check if the subdomain exists
|
|
if subdomains[static.Subdomain] == nil {
|
|
subdomains[static.Subdomain] = chi.NewRouter()
|
|
slog.Info("Mapping subdomain " + static.Subdomain)
|
|
hostRouter.Map(static.Subdomain, subdomains[static.Subdomain])
|
|
}
|
|
}
|
|
}
|
|
|
|
var globalOutbox = make(chan library.InterServiceMessage)
|
|
|
|
// Initialize the service discovery, health-check, and logging services
|
|
// Since these are core services, always allocate them the service IDs 0, 1, and 2
|
|
// These are not dynamically loaded, as they are integral to the system functioning
|
|
go processInterServiceMessage(globalOutbox)
|
|
|
|
// Initialize all the services
|
|
plugins := make(map[time.Time]string)
|
|
err := filepath.Walk(config.Global.ServiceDirectory, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if info.IsDir() || filepath.Ext(path) != ".fgs" {
|
|
return nil
|
|
}
|
|
|
|
// Add the plugin to the list of plugins
|
|
if info.Name() == "storage.fgs" {
|
|
plugins[time.Unix(0, 0)] = path
|
|
return nil
|
|
} else if info.Name() == "auth.fgs" {
|
|
plugins[time.Unix(0, 1)] = path
|
|
return nil
|
|
}
|
|
|
|
plugins[info.ModTime()] = path
|
|
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
slog.Error("Error walking the services directory: ", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Sort the plugins by modification time, newest last
|
|
var keys []time.Time
|
|
for k := range plugins {
|
|
keys = append(keys, k)
|
|
}
|
|
|
|
sort.Slice(keys, func(i, j int) bool {
|
|
return keys[i].Before(keys[j])
|
|
})
|
|
|
|
for _, k := range keys {
|
|
// Get the plugin path
|
|
pluginPath := plugins[k]
|
|
|
|
// Load the plugin
|
|
servicePlugin, err := plugin.Open(pluginPath)
|
|
if err != nil {
|
|
slog.Error("Could not load service: ", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Load the service information
|
|
serviceInformationSymbol, err := servicePlugin.Lookup("ServiceInformation")
|
|
if err != nil {
|
|
slog.Error("Service lacks necessary information: ", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
serviceInformation := *serviceInformationSymbol.(*library.Service)
|
|
|
|
// Load the main function
|
|
main, err := servicePlugin.Lookup("Main")
|
|
if err != nil {
|
|
slog.Error("Service lacks necessary main function: ", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Initialize the service
|
|
var inbox = make(chan library.InterServiceMessage)
|
|
lock.Lock()
|
|
services[serviceInformation.ServiceID] = Service{
|
|
ServiceID: serviceInformation.ServiceID,
|
|
Inbox: inbox,
|
|
ServiceMetadata: serviceInformation,
|
|
}
|
|
lock.Unlock()
|
|
|
|
slog.Info("Activating service " + serviceInformation.Name + " with ID " + serviceInformation.ServiceID.String())
|
|
|
|
// Make finalRouter a subdomain router if necessary
|
|
var finalRouter *chi.Mux
|
|
if config.Services[strings.ToLower(serviceInformation.Name)].(map[string]interface{})["subdomain"] != nil {
|
|
finalRouter = subdomains[config.Services[strings.ToLower(serviceInformation.Name)].(map[string]interface{})["subdomain"].(string)]
|
|
} else {
|
|
finalRouter = router
|
|
}
|
|
|
|
// Check if they want a resource directory
|
|
var resourceDir fs.FS = nil
|
|
if serviceInformation.Permissions.Resources {
|
|
resourceDir = os.DirFS(filepath.Join(config.Global.ResourceDirectory, serviceInformation.ServiceID.String()))
|
|
}
|
|
|
|
main.(func(library.ServiceInitializationInformation))(library.ServiceInitializationInformation{
|
|
Domain: serviceInformation.Name,
|
|
Configuration: config.Services[strings.ToLower(serviceInformation.Name)].(map[string]interface{}),
|
|
Outbox: globalOutbox,
|
|
Inbox: inbox,
|
|
ResourceDir: resourceDir,
|
|
Router: finalRouter,
|
|
})
|
|
|
|
// Log the service activation
|
|
slog.Info("Service " + serviceInformation.Name + " activated with ID " + serviceInformation.ServiceID.String())
|
|
}
|
|
|
|
// Mount the host router
|
|
router.Mount("/", hostRouter)
|
|
slog.Info("All subdomains mapped")
|
|
|
|
// Initialize the static file servers
|
|
for _, static := range config.Static {
|
|
if static.Subdomain != "" {
|
|
// Serve the static directory
|
|
if static.Pattern != "" {
|
|
subdomains[static.Subdomain].Handle(static.Pattern, http.FileServerFS(os.DirFS(static.Directory)))
|
|
slog.Info("Serving static directory " + static.Directory + " on subdomain " + static.Subdomain + " with pattern " + static.Pattern)
|
|
} else {
|
|
subdomains[static.Subdomain].Handle("/*", http.FileServerFS(os.DirFS(static.Directory)))
|
|
slog.Info("Serving static directory " + static.Directory + " on subdomain " + static.Subdomain)
|
|
}
|
|
} else {
|
|
// Serve the static directory
|
|
if static.Pattern != "" {
|
|
router.Handle(static.Pattern, http.FileServerFS(os.DirFS(static.Directory)))
|
|
slog.Info("Serving static directory " + static.Directory + " with pattern " + static.Pattern)
|
|
} else {
|
|
router.Handle("/*", http.FileServerFS(os.DirFS(static.Directory)))
|
|
slog.Info("Serving static directory " + static.Directory)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Start the server
|
|
slog.Info("Starting server on " + config.Global.IP + ":" + config.Global.Port)
|
|
switch config.Global.Compression {
|
|
case "":
|
|
err = http.ListenAndServe(config.Global.IP+":"+config.Global.Port, router)
|
|
case "gzip":
|
|
slog.Info("GZip compression enabled")
|
|
err = http.ListenAndServe(config.Global.IP+":"+config.Global.Port, gzipHandler(router))
|
|
case "brotli":
|
|
slog.Info("Brotli compression enabled")
|
|
err = http.ListenAndServe(config.Global.IP+":"+config.Global.Port, brotliHandler(router))
|
|
case "zstd":
|
|
slog.Info("ZStandard compression enabled")
|
|
err = http.ListenAndServe(config.Global.IP+":"+config.Global.Port, zStandardHandler(router))
|
|
}
|
|
if err != nil {
|
|
slog.Error("Error starting server: ", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|