mirror of
https://github.com/hoernschen/dendrite.git
synced 2025-07-30 21:12:45 +00:00
Remove polylith/API mode (#2967)
This removes most of the code used for polylith/API mode. This removes the `/api` internal endpoints entirely. Binary size change roughly 5%: ``` 51437560 Feb 13 10:15 dendrite-monolith-server # old 48759008 Feb 13 10:15 dendrite-monolith-server # new ```
This commit is contained in:
Till
GitHub
parent
cc59879faa
commit
11d9b9db0e
106 changed files with 374 additions and 5850 deletions
|
|
@ -17,7 +17,6 @@ package base
|
|||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/tls"
|
||||
"database/sql"
|
||||
"embed"
|
||||
"encoding/json"
|
||||
|
|
@ -38,8 +37,6 @@ import (
|
|||
"github.com/matrix-org/gomatrixserverlib"
|
||||
"github.com/prometheus/client_golang/prometheus/promhttp"
|
||||
"go.uber.org/atomic"
|
||||
"golang.org/x/net/http2"
|
||||
"golang.org/x/net/http2/h2c"
|
||||
|
||||
"github.com/matrix-org/dendrite/internal"
|
||||
"github.com/matrix-org/dendrite/internal/caching"
|
||||
|
|
@ -53,19 +50,9 @@ import (
|
|||
|
||||
"github.com/sirupsen/logrus"
|
||||
|
||||
appserviceAPI "github.com/matrix-org/dendrite/appservice/api"
|
||||
asinthttp "github.com/matrix-org/dendrite/appservice/inthttp"
|
||||
federationAPI "github.com/matrix-org/dendrite/federationapi/api"
|
||||
federationIntHTTP "github.com/matrix-org/dendrite/federationapi/inthttp"
|
||||
keyserverAPI "github.com/matrix-org/dendrite/keyserver/api"
|
||||
keyinthttp "github.com/matrix-org/dendrite/keyserver/inthttp"
|
||||
roomserverAPI "github.com/matrix-org/dendrite/roomserver/api"
|
||||
rsinthttp "github.com/matrix-org/dendrite/roomserver/inthttp"
|
||||
"github.com/matrix-org/dendrite/setup/config"
|
||||
"github.com/matrix-org/dendrite/setup/jetstream"
|
||||
"github.com/matrix-org/dendrite/setup/process"
|
||||
userapi "github.com/matrix-org/dendrite/userapi/api"
|
||||
userapiinthttp "github.com/matrix-org/dendrite/userapi/inthttp"
|
||||
)
|
||||
|
||||
//go:embed static/*.gotmpl
|
||||
|
|
@ -78,7 +65,6 @@ var staticContent embed.FS
|
|||
// Must be closed when shutting down.
|
||||
type BaseDendrite struct {
|
||||
*process.ProcessContext
|
||||
componentName string
|
||||
tracerCloser io.Closer
|
||||
PublicClientAPIMux *mux.Router
|
||||
PublicFederationAPIMux *mux.Router
|
||||
|
|
@ -86,12 +72,9 @@ type BaseDendrite struct {
|
|||
PublicMediaAPIMux *mux.Router
|
||||
PublicWellKnownAPIMux *mux.Router
|
||||
PublicStaticMux *mux.Router
|
||||
InternalAPIMux *mux.Router
|
||||
DendriteAdminMux *mux.Router
|
||||
SynapseAdminMux *mux.Router
|
||||
NATS *jetstream.NATSInstance
|
||||
UseHTTPAPIs bool
|
||||
apiHttpClient *http.Client
|
||||
Cfg *config.Dendrite
|
||||
Caches *caching.Caches
|
||||
DNSCache *gomatrixserverlib.DNSCache
|
||||
|
|
@ -105,38 +88,26 @@ type BaseDendrite struct {
|
|||
const NoListener = ""
|
||||
|
||||
const HTTPServerTimeout = time.Minute * 5
|
||||
const HTTPClientTimeout = time.Second * 30
|
||||
|
||||
type BaseDendriteOptions int
|
||||
|
||||
const (
|
||||
DisableMetrics BaseDendriteOptions = iota
|
||||
UseHTTPAPIs
|
||||
PolylithMode
|
||||
)
|
||||
|
||||
// NewBaseDendrite creates a new instance to be used by a component.
|
||||
// The componentName is used for logging purposes, and should be a friendly name
|
||||
// of the compontent running, e.g. "SyncAPI"
|
||||
func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...BaseDendriteOptions) *BaseDendrite {
|
||||
func NewBaseDendrite(cfg *config.Dendrite, options ...BaseDendriteOptions) *BaseDendrite {
|
||||
platformSanityChecks()
|
||||
useHTTPAPIs := false
|
||||
enableMetrics := true
|
||||
isMonolith := true
|
||||
for _, opt := range options {
|
||||
switch opt {
|
||||
case DisableMetrics:
|
||||
enableMetrics = false
|
||||
case UseHTTPAPIs:
|
||||
useHTTPAPIs = true
|
||||
case PolylithMode:
|
||||
isMonolith = false
|
||||
useHTTPAPIs = true
|
||||
}
|
||||
}
|
||||
|
||||
configErrors := &config.ConfigErrors{}
|
||||
cfg.Verify(configErrors, isMonolith)
|
||||
cfg.Verify(configErrors)
|
||||
if len(*configErrors) > 0 {
|
||||
for _, err := range *configErrors {
|
||||
logrus.Errorf("Configuration error: %s", err)
|
||||
|
|
@ -145,7 +116,7 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...Base
|
|||
}
|
||||
|
||||
internal.SetupStdLogging()
|
||||
internal.SetupHookLogging(cfg.Logging, componentName)
|
||||
internal.SetupHookLogging(cfg.Logging)
|
||||
internal.SetupPprof()
|
||||
|
||||
logrus.Infof("Dendrite version %s", internal.VersionString())
|
||||
|
|
@ -154,14 +125,13 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...Base
|
|||
logrus.Warn("Open registration is enabled")
|
||||
}
|
||||
|
||||
closer, err := cfg.SetupTracing("Dendrite" + componentName)
|
||||
closer, err := cfg.SetupTracing()
|
||||
if err != nil {
|
||||
logrus.WithError(err).Panicf("failed to start opentracing")
|
||||
}
|
||||
|
||||
var fts *fulltext.Search
|
||||
isSyncOrMonolith := componentName == "syncapi" || isMonolith
|
||||
if cfg.SyncAPI.Fulltext.Enabled && isSyncOrMonolith {
|
||||
if cfg.SyncAPI.Fulltext.Enabled {
|
||||
fts, err = fulltext.New(cfg.SyncAPI.Fulltext)
|
||||
if err != nil {
|
||||
logrus.WithError(err).Panicf("failed to create full text")
|
||||
|
|
@ -196,32 +166,12 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...Base
|
|||
)
|
||||
}
|
||||
|
||||
apiClient := http.Client{
|
||||
Timeout: time.Minute * 10,
|
||||
Transport: &http2.Transport{
|
||||
AllowHTTP: true,
|
||||
DialTLS: func(network, addr string, _ *tls.Config) (net.Conn, error) {
|
||||
// Ordinarily HTTP/2 would expect TLS, but the remote listener is
|
||||
// H2C-enabled (HTTP/2 without encryption). Overriding the DialTLS
|
||||
// function with a plain Dial allows us to trick the HTTP client
|
||||
// into establishing a HTTP/2 connection without TLS.
|
||||
// TODO: Eventually we will want to look at authenticating and
|
||||
// encrypting these internal HTTP APIs, at which point we will have
|
||||
// to reconsider H2C and change all this anyway.
|
||||
return net.Dial(network, addr)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
// If we're in monolith mode, we'll set up a global pool of database
|
||||
// connections. A component is welcome to use this pool if they don't
|
||||
// have a separate database config of their own.
|
||||
var db *sql.DB
|
||||
var writer sqlutil.Writer
|
||||
if cfg.Global.DatabaseOptions.ConnectionString != "" {
|
||||
if !isMonolith {
|
||||
logrus.Panic("Using a global database connection pool is not supported in polylith deployments")
|
||||
}
|
||||
if cfg.Global.DatabaseOptions.ConnectionString.IsSQLite() {
|
||||
logrus.Panic("Using a global database connection pool is not supported with SQLite databases")
|
||||
}
|
||||
|
|
@ -246,8 +196,6 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...Base
|
|||
|
||||
return &BaseDendrite{
|
||||
ProcessContext: process.NewProcessContext(),
|
||||
componentName: componentName,
|
||||
UseHTTPAPIs: useHTTPAPIs,
|
||||
tracerCloser: closer,
|
||||
Cfg: cfg,
|
||||
Caches: caching.NewRistrettoCache(cfg.Global.Cache.EstimatedMaxSize, cfg.Global.Cache.MaxAge, enableMetrics),
|
||||
|
|
@ -258,11 +206,9 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, options ...Base
|
|||
PublicMediaAPIMux: mux.NewRouter().SkipClean(true).PathPrefix(httputil.PublicMediaPathPrefix).Subrouter().UseEncodedPath(),
|
||||
PublicWellKnownAPIMux: mux.NewRouter().SkipClean(true).PathPrefix(httputil.PublicWellKnownPrefix).Subrouter().UseEncodedPath(),
|
||||
PublicStaticMux: mux.NewRouter().SkipClean(true).PathPrefix(httputil.PublicStaticPath).Subrouter().UseEncodedPath(),
|
||||
InternalAPIMux: mux.NewRouter().SkipClean(true).PathPrefix(httputil.InternalPathPrefix).Subrouter().UseEncodedPath(),
|
||||
DendriteAdminMux: mux.NewRouter().SkipClean(true).PathPrefix(httputil.DendriteAdminPathPrefix).Subrouter().UseEncodedPath(),
|
||||
SynapseAdminMux: mux.NewRouter().SkipClean(true).PathPrefix(httputil.SynapseAdminPathPrefix).Subrouter().UseEncodedPath(),
|
||||
NATS: &jetstream.NATSInstance{},
|
||||
apiHttpClient: &apiClient,
|
||||
Database: db, // set if monolith with global connection pool only
|
||||
DatabaseWriter: writer, // set if monolith with global connection pool only
|
||||
EnableMetrics: enableMetrics,
|
||||
|
|
@ -300,52 +246,6 @@ func (b *BaseDendrite) DatabaseConnection(dbProperties *config.DatabaseOptions,
|
|||
return nil, nil, fmt.Errorf("no database connections configured")
|
||||
}
|
||||
|
||||
// AppserviceHTTPClient returns the AppServiceInternalAPI for hitting the appservice component over HTTP.
|
||||
func (b *BaseDendrite) AppserviceHTTPClient() appserviceAPI.AppServiceInternalAPI {
|
||||
a, err := asinthttp.NewAppserviceClient(b.Cfg.AppServiceURL(), b.apiHttpClient)
|
||||
if err != nil {
|
||||
logrus.WithError(err).Panic("CreateHTTPAppServiceAPIs failed")
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
// RoomserverHTTPClient returns RoomserverInternalAPI for hitting the roomserver over HTTP.
|
||||
func (b *BaseDendrite) RoomserverHTTPClient() roomserverAPI.RoomserverInternalAPI {
|
||||
rsAPI, err := rsinthttp.NewRoomserverClient(b.Cfg.RoomServerURL(), b.apiHttpClient, b.Caches)
|
||||
if err != nil {
|
||||
logrus.WithError(err).Panic("RoomserverHTTPClient failed", b.apiHttpClient)
|
||||
}
|
||||
return rsAPI
|
||||
}
|
||||
|
||||
// UserAPIClient returns UserInternalAPI for hitting the userapi over HTTP.
|
||||
func (b *BaseDendrite) UserAPIClient() userapi.UserInternalAPI {
|
||||
userAPI, err := userapiinthttp.NewUserAPIClient(b.Cfg.UserAPIURL(), b.apiHttpClient)
|
||||
if err != nil {
|
||||
logrus.WithError(err).Panic("UserAPIClient failed", b.apiHttpClient)
|
||||
}
|
||||
return userAPI
|
||||
}
|
||||
|
||||
// FederationAPIHTTPClient returns FederationInternalAPI for hitting
|
||||
// the federation API server over HTTP
|
||||
func (b *BaseDendrite) FederationAPIHTTPClient() federationAPI.FederationInternalAPI {
|
||||
f, err := federationIntHTTP.NewFederationAPIClient(b.Cfg.FederationAPIURL(), b.apiHttpClient, b.Caches)
|
||||
if err != nil {
|
||||
logrus.WithError(err).Panic("FederationAPIHTTPClient failed", b.apiHttpClient)
|
||||
}
|
||||
return f
|
||||
}
|
||||
|
||||
// KeyServerHTTPClient returns KeyInternalAPI for hitting the key server over HTTP
|
||||
func (b *BaseDendrite) KeyServerHTTPClient() keyserverAPI.KeyInternalAPI {
|
||||
f, err := keyinthttp.NewKeyServerClient(b.Cfg.KeyServerURL(), b.apiHttpClient)
|
||||
if err != nil {
|
||||
logrus.WithError(err).Panic("KeyServerHTTPClient failed", b.apiHttpClient)
|
||||
}
|
||||
return f
|
||||
}
|
||||
|
||||
// PushGatewayHTTPClient returns a new client for interacting with (external) Push Gateways.
|
||||
func (b *BaseDendrite) PushGatewayHTTPClient() pushgateway.Client {
|
||||
return pushgateway.NewHTTPClient(b.Cfg.UserAPI.PushGatewayDisableTLSValidation)
|
||||
|
|
@ -442,20 +342,18 @@ func (b *BaseDendrite) ConfigureAdminEndpoints() {
|
|||
})
|
||||
}
|
||||
|
||||
// SetupAndServeHTTP sets up the HTTP server to serve endpoints registered on
|
||||
// ApiMux under /api/ and adds a prometheus handler under /metrics.
|
||||
// SetupAndServeHTTP sets up the HTTP server to serve client & federation APIs
|
||||
// and adds a prometheus handler under /_dendrite/metrics.
|
||||
func (b *BaseDendrite) SetupAndServeHTTP(
|
||||
internalHTTPAddr, externalHTTPAddr config.HTTPAddress,
|
||||
externalHTTPAddr config.HTTPAddress,
|
||||
certFile, keyFile *string,
|
||||
) {
|
||||
// Manually unlocked right before actually serving requests,
|
||||
// as we don't return from this method (defer doesn't work).
|
||||
b.startupLock.Lock()
|
||||
internalAddr, _ := internalHTTPAddr.Address()
|
||||
externalAddr, _ := externalHTTPAddr.Address()
|
||||
|
||||
externalRouter := mux.NewRouter().SkipClean(true).UseEncodedPath()
|
||||
internalRouter := externalRouter
|
||||
|
||||
externalServ := &http.Server{
|
||||
Addr: string(externalAddr),
|
||||
|
|
@ -465,25 +363,6 @@ func (b *BaseDendrite) SetupAndServeHTTP(
|
|||
return b.ProcessContext.Context()
|
||||
},
|
||||
}
|
||||
internalServ := externalServ
|
||||
|
||||
if internalAddr != NoListener && externalAddr != internalAddr {
|
||||
// H2C allows us to accept HTTP/2 connections without TLS
|
||||
// encryption. Since we don't currently require any form of
|
||||
// authentication or encryption on these internal HTTP APIs,
|
||||
// H2C gives us all of the advantages of HTTP/2 (such as
|
||||
// stream multiplexing and avoiding head-of-line blocking)
|
||||
// without enabling TLS.
|
||||
internalH2S := &http2.Server{}
|
||||
internalRouter = mux.NewRouter().SkipClean(true).UseEncodedPath()
|
||||
internalServ = &http.Server{
|
||||
Addr: string(internalAddr),
|
||||
Handler: h2c.NewHandler(internalRouter, internalH2S),
|
||||
BaseContext: func(_ net.Listener) context.Context {
|
||||
return b.ProcessContext.Context()
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
b.configureHTTPErrors()
|
||||
|
||||
|
|
@ -492,9 +371,8 @@ func (b *BaseDendrite) SetupAndServeHTTP(
|
|||
http.Redirect(w, r, httputil.PublicStaticPath, http.StatusFound)
|
||||
})
|
||||
|
||||
internalRouter.PathPrefix(httputil.InternalPathPrefix).Handler(b.InternalAPIMux)
|
||||
if b.Cfg.Global.Metrics.Enabled {
|
||||
internalRouter.Handle("/metrics", httputil.WrapHandlerInBasicAuth(promhttp.Handler(), b.Cfg.Global.Metrics.BasicAuth))
|
||||
externalRouter.Handle("/metrics", httputil.WrapHandlerInBasicAuth(promhttp.Handler(), b.Cfg.Global.Metrics.BasicAuth))
|
||||
}
|
||||
|
||||
b.ConfigureAdminEndpoints()
|
||||
|
|
@ -528,7 +406,7 @@ func (b *BaseDendrite) SetupAndServeHTTP(
|
|||
})
|
||||
federationHandler = sentryHandler.Handle(b.PublicFederationAPIMux)
|
||||
}
|
||||
internalRouter.PathPrefix(httputil.DendriteAdminPathPrefix).Handler(b.DendriteAdminMux)
|
||||
externalRouter.PathPrefix(httputil.DendriteAdminPathPrefix).Handler(b.DendriteAdminMux)
|
||||
externalRouter.PathPrefix(httputil.PublicClientPathPrefix).Handler(clientHandler)
|
||||
if !b.Cfg.Global.DisableFederation {
|
||||
externalRouter.PathPrefix(httputil.PublicKeyPathPrefix).Handler(b.PublicKeyAPIMux)
|
||||
|
|
@ -540,38 +418,11 @@ func (b *BaseDendrite) SetupAndServeHTTP(
|
|||
externalRouter.PathPrefix(httputil.PublicStaticPath).Handler(b.PublicStaticMux)
|
||||
|
||||
b.startupLock.Unlock()
|
||||
if internalAddr != NoListener && internalAddr != externalAddr {
|
||||
go func() {
|
||||
var internalShutdown atomic.Bool // RegisterOnShutdown can be called more than once
|
||||
logrus.Infof("Starting internal %s listener on %s", b.componentName, internalServ.Addr)
|
||||
b.ProcessContext.ComponentStarted()
|
||||
internalServ.RegisterOnShutdown(func() {
|
||||
if internalShutdown.CompareAndSwap(false, true) {
|
||||
b.ProcessContext.ComponentFinished()
|
||||
logrus.Infof("Stopped internal HTTP listener")
|
||||
}
|
||||
})
|
||||
if certFile != nil && keyFile != nil {
|
||||
if err := internalServ.ListenAndServeTLS(*certFile, *keyFile); err != nil {
|
||||
if err != http.ErrServerClosed {
|
||||
logrus.WithError(err).Fatal("failed to serve HTTPS")
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if err := internalServ.ListenAndServe(); err != nil {
|
||||
if err != http.ErrServerClosed {
|
||||
logrus.WithError(err).Fatal("failed to serve HTTP")
|
||||
}
|
||||
}
|
||||
}
|
||||
logrus.Infof("Stopped internal %s listener on %s", b.componentName, internalServ.Addr)
|
||||
}()
|
||||
}
|
||||
|
||||
if externalAddr != NoListener {
|
||||
go func() {
|
||||
var externalShutdown atomic.Bool // RegisterOnShutdown can be called more than once
|
||||
logrus.Infof("Starting external %s listener on %s", b.componentName, externalServ.Addr)
|
||||
logrus.Infof("Starting external listener on %s", externalServ.Addr)
|
||||
b.ProcessContext.ComponentStarted()
|
||||
externalServ.RegisterOnShutdown(func() {
|
||||
if externalShutdown.CompareAndSwap(false, true) {
|
||||
|
|
@ -592,7 +443,7 @@ func (b *BaseDendrite) SetupAndServeHTTP(
|
|||
}
|
||||
}
|
||||
}
|
||||
logrus.Infof("Stopped external %s listener on %s", b.componentName, externalServ.Addr)
|
||||
logrus.Infof("Stopped external listener on %s", externalServ.Addr)
|
||||
}()
|
||||
}
|
||||
|
||||
|
|
@ -600,7 +451,6 @@ func (b *BaseDendrite) SetupAndServeHTTP(
|
|||
<-b.ProcessContext.WaitForShutdown()
|
||||
|
||||
logrus.Infof("Stopping HTTP listeners")
|
||||
_ = internalServ.Shutdown(context.Background())
|
||||
_ = externalServ.Shutdown(context.Background())
|
||||
logrus.Infof("Stopped HTTP listeners")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ func TestLandingPage(t *testing.T) {
|
|||
s.Close()
|
||||
|
||||
// start base with the listener and wait for it to be started
|
||||
go b.SetupAndServeHTTP("", config.HTTPAddress(s.URL), nil, nil)
|
||||
go b.SetupAndServeHTTP(config.HTTPAddress(s.URL), nil, nil)
|
||||
time.Sleep(time.Millisecond * 10)
|
||||
|
||||
// When hitting /, we should be redirected to /_matrix/static, which should contain the landing page
|
||||
|
|
|
|||
|
|
@ -79,8 +79,6 @@ type Dendrite struct {
|
|||
|
||||
// Any information derived from the configuration options for later use.
|
||||
Derived Derived `yaml:"-"`
|
||||
|
||||
IsMonolith bool `yaml:"-"`
|
||||
}
|
||||
|
||||
// TODO: Kill Derived
|
||||
|
|
@ -114,15 +112,6 @@ type Derived struct {
|
|||
// servers from creating RoomIDs in exclusive application service namespaces
|
||||
}
|
||||
|
||||
type InternalAPIOptions struct {
|
||||
Listen HTTPAddress `yaml:"listen"`
|
||||
Connect HTTPAddress `yaml:"connect"`
|
||||
}
|
||||
|
||||
type ExternalAPIOptions struct {
|
||||
Listen HTTPAddress `yaml:"listen"`
|
||||
}
|
||||
|
||||
// A Path on the filesystem.
|
||||
type Path string
|
||||
|
||||
|
|
@ -191,7 +180,7 @@ type ConfigErrors []string
|
|||
|
||||
// Load a yaml config file for a server run as multiple processes or as a monolith.
|
||||
// Checks the config to ensure that it is valid.
|
||||
func Load(configPath string, monolith bool) (*Dendrite, error) {
|
||||
func Load(configPath string) (*Dendrite, error) {
|
||||
configData, err := os.ReadFile(configPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
|
@ -202,28 +191,26 @@ func Load(configPath string, monolith bool) (*Dendrite, error) {
|
|||
}
|
||||
// Pass the current working directory and os.ReadFile so that they can
|
||||
// be mocked in the tests
|
||||
return loadConfig(basePath, configData, os.ReadFile, monolith)
|
||||
return loadConfig(basePath, configData, os.ReadFile)
|
||||
}
|
||||
|
||||
func loadConfig(
|
||||
basePath string,
|
||||
configData []byte,
|
||||
readFile func(string) ([]byte, error),
|
||||
monolithic bool,
|
||||
) (*Dendrite, error) {
|
||||
var c Dendrite
|
||||
c.Defaults(DefaultOpts{
|
||||
Generate: false,
|
||||
Monolithic: monolithic,
|
||||
Generate: false,
|
||||
SingleDatabase: true,
|
||||
})
|
||||
c.IsMonolith = monolithic
|
||||
|
||||
var err error
|
||||
if err = yaml.Unmarshal(configData, &c); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err = c.check(monolithic); err != nil {
|
||||
if err = c.check(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
|
|
@ -333,8 +320,8 @@ func (config *Dendrite) Derive() error {
|
|||
}
|
||||
|
||||
type DefaultOpts struct {
|
||||
Generate bool
|
||||
Monolithic bool
|
||||
Generate bool
|
||||
SingleDatabase bool
|
||||
}
|
||||
|
||||
// SetDefaults sets default config values if they are not explicitly set.
|
||||
|
|
@ -355,9 +342,9 @@ func (c *Dendrite) Defaults(opts DefaultOpts) {
|
|||
c.Wiring()
|
||||
}
|
||||
|
||||
func (c *Dendrite) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
func (c *Dendrite) Verify(configErrs *ConfigErrors) {
|
||||
type verifiable interface {
|
||||
Verify(configErrs *ConfigErrors, isMonolith bool)
|
||||
Verify(configErrs *ConfigErrors)
|
||||
}
|
||||
for _, c := range []verifiable{
|
||||
&c.Global, &c.ClientAPI, &c.FederationAPI,
|
||||
|
|
@ -365,7 +352,7 @@ func (c *Dendrite) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
|||
&c.SyncAPI, &c.UserAPI,
|
||||
&c.AppServiceAPI, &c.RelayAPI, &c.MSCs,
|
||||
} {
|
||||
c.Verify(configErrs, isMonolith)
|
||||
c.Verify(configErrs)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -415,14 +402,6 @@ func checkNotEmpty(configErrs *ConfigErrors, key, value string) {
|
|||
}
|
||||
}
|
||||
|
||||
// checkNotZero verifies the given value is not zero in the configuration.
|
||||
// If it is, adds an error to the list.
|
||||
func checkNotZero(configErrs *ConfigErrors, key string, value int64) {
|
||||
if value == 0 {
|
||||
configErrs.Add(fmt.Sprintf("missing config key %q", key))
|
||||
}
|
||||
}
|
||||
|
||||
// checkPositive verifies the given value is positive (zero included)
|
||||
// in the configuration. If it is not, adds an error to the list.
|
||||
func checkPositive(configErrs *ConfigErrors, key string, value int64) {
|
||||
|
|
@ -431,26 +410,6 @@ func checkPositive(configErrs *ConfigErrors, key string, value int64) {
|
|||
}
|
||||
}
|
||||
|
||||
// checkURL verifies that the parameter is a valid URL
|
||||
func checkURL(configErrs *ConfigErrors, key, value string) {
|
||||
if value == "" {
|
||||
configErrs.Add(fmt.Sprintf("missing config key %q", key))
|
||||
return
|
||||
}
|
||||
url, err := url.Parse(value)
|
||||
if err != nil {
|
||||
configErrs.Add(fmt.Sprintf("config key %q contains invalid URL (%s)", key, err.Error()))
|
||||
return
|
||||
}
|
||||
switch url.Scheme {
|
||||
case "http":
|
||||
case "https":
|
||||
default:
|
||||
configErrs.Add(fmt.Sprintf("config key %q URL should be http:// or https://", key))
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
// checkLogging verifies the parameters logging.* are valid.
|
||||
func (config *Dendrite) checkLogging(configErrs *ConfigErrors) {
|
||||
for _, logrusHook := range config.Logging {
|
||||
|
|
@ -461,7 +420,7 @@ func (config *Dendrite) checkLogging(configErrs *ConfigErrors) {
|
|||
|
||||
// check returns an error type containing all errors found within the config
|
||||
// file.
|
||||
func (config *Dendrite) check(_ bool) error { // monolithic
|
||||
func (config *Dendrite) check() error { // monolithic
|
||||
var configErrs ConfigErrors
|
||||
|
||||
if config.Version != Version {
|
||||
|
|
@ -528,58 +487,13 @@ func readKeyPEM(path string, data []byte, enforceKeyIDFormat bool) (gomatrixserv
|
|||
}
|
||||
}
|
||||
|
||||
// AppServiceURL returns a HTTP URL for where the appservice component is listening.
|
||||
func (config *Dendrite) AppServiceURL() string {
|
||||
// Hard code the appservice server to talk HTTP for now.
|
||||
// If we support HTTPS we need to think of a practical way to do certificate validation.
|
||||
// People setting up servers shouldn't need to get a certificate valid for the public
|
||||
// internet for an internal API.
|
||||
return string(config.AppServiceAPI.InternalAPI.Connect)
|
||||
}
|
||||
|
||||
// FederationAPIURL returns an HTTP URL for where the federation API is listening.
|
||||
func (config *Dendrite) FederationAPIURL() string {
|
||||
// Hard code the federationapi to talk HTTP for now.
|
||||
// If we support HTTPS we need to think of a practical way to do certificate validation.
|
||||
// People setting up servers shouldn't need to get a certificate valid for the public
|
||||
// internet for an internal API.
|
||||
return string(config.FederationAPI.InternalAPI.Connect)
|
||||
}
|
||||
|
||||
// RoomServerURL returns an HTTP URL for where the roomserver is listening.
|
||||
func (config *Dendrite) RoomServerURL() string {
|
||||
// Hard code the roomserver to talk HTTP for now.
|
||||
// If we support HTTPS we need to think of a practical way to do certificate validation.
|
||||
// People setting up servers shouldn't need to get a certificate valid for the public
|
||||
// internet for an internal API.
|
||||
return string(config.RoomServer.InternalAPI.Connect)
|
||||
}
|
||||
|
||||
// UserAPIURL returns an HTTP URL for where the userapi is listening.
|
||||
func (config *Dendrite) UserAPIURL() string {
|
||||
// Hard code the userapi to talk HTTP for now.
|
||||
// If we support HTTPS we need to think of a practical way to do certificate validation.
|
||||
// People setting up servers shouldn't need to get a certificate valid for the public
|
||||
// internet for an internal API.
|
||||
return string(config.UserAPI.InternalAPI.Connect)
|
||||
}
|
||||
|
||||
// KeyServerURL returns an HTTP URL for where the key server is listening.
|
||||
func (config *Dendrite) KeyServerURL() string {
|
||||
// Hard code the key server to talk HTTP for now.
|
||||
// If we support HTTPS we need to think of a practical way to do certificate validation.
|
||||
// People setting up servers shouldn't need to get a certificate valid for the public
|
||||
// internet for an internal API.
|
||||
return string(config.KeyServer.InternalAPI.Connect)
|
||||
}
|
||||
|
||||
// SetupTracing configures the opentracing using the supplied configuration.
|
||||
func (config *Dendrite) SetupTracing(serviceName string) (closer io.Closer, err error) {
|
||||
func (config *Dendrite) SetupTracing() (closer io.Closer, err error) {
|
||||
if !config.Tracing.Enabled {
|
||||
return io.NopCloser(bytes.NewReader([]byte{})), nil
|
||||
}
|
||||
return config.Tracing.Jaeger.InitGlobalTracer(
|
||||
serviceName,
|
||||
"Dendrite",
|
||||
jaegerconfig.Logger(logrusLogger{logrus.StandardLogger()}),
|
||||
jaegerconfig.Metrics(jaegermetrics.NullFactory),
|
||||
)
|
||||
|
|
|
|||
|
|
@ -22,15 +22,13 @@ import (
|
|||
"strings"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
yaml "gopkg.in/yaml.v2"
|
||||
"gopkg.in/yaml.v2"
|
||||
)
|
||||
|
||||
type AppServiceAPI struct {
|
||||
Matrix *Global `yaml:"-"`
|
||||
Derived *Derived `yaml:"-"` // TODO: Nuke Derived from orbit
|
||||
|
||||
InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
|
||||
|
||||
// DisableTLSValidation disables the validation of X.509 TLS certs
|
||||
// on appservice endpoints. This is not recommended in production!
|
||||
DisableTLSValidation bool `yaml:"disable_tls_validation"`
|
||||
|
|
@ -39,18 +37,9 @@ type AppServiceAPI struct {
|
|||
}
|
||||
|
||||
func (c *AppServiceAPI) Defaults(opts DefaultOpts) {
|
||||
if !opts.Monolithic {
|
||||
c.InternalAPI.Listen = "http://localhost:7777"
|
||||
c.InternalAPI.Connect = "http://localhost:7777"
|
||||
}
|
||||
}
|
||||
|
||||
func (c *AppServiceAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
checkURL(configErrs, "app_service_api.internal_api.listen", string(c.InternalAPI.Listen))
|
||||
checkURL(configErrs, "app_service_api.internal_api.connect", string(c.InternalAPI.Connect))
|
||||
func (c *AppServiceAPI) Verify(configErrs *ConfigErrors) {
|
||||
}
|
||||
|
||||
// ApplicationServiceNamespace is the namespace that a specific application
|
||||
|
|
|
|||
|
|
@ -9,9 +9,6 @@ type ClientAPI struct {
|
|||
Matrix *Global `yaml:"-"`
|
||||
Derived *Derived `yaml:"-"` // TODO: Nuke Derived from orbit
|
||||
|
||||
InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
|
||||
ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
|
||||
|
||||
// If set disables new users from registering (except via shared
|
||||
// secrets)
|
||||
RegistrationDisabled bool `yaml:"registration_disabled"`
|
||||
|
|
@ -58,11 +55,6 @@ type ClientAPI struct {
|
|||
}
|
||||
|
||||
func (c *ClientAPI) Defaults(opts DefaultOpts) {
|
||||
if !opts.Monolithic {
|
||||
c.InternalAPI.Listen = "http://localhost:7771"
|
||||
c.InternalAPI.Connect = "http://localhost:7771"
|
||||
c.ExternalAPI.Listen = "http://[::]:8071"
|
||||
}
|
||||
c.RegistrationSharedSecret = ""
|
||||
c.RecaptchaPublicKey = ""
|
||||
c.RecaptchaPrivateKey = ""
|
||||
|
|
@ -74,7 +66,7 @@ func (c *ClientAPI) Defaults(opts DefaultOpts) {
|
|||
c.RateLimiting.Defaults()
|
||||
}
|
||||
|
||||
func (c *ClientAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
func (c *ClientAPI) Verify(configErrs *ConfigErrors) {
|
||||
c.TURN.Verify(configErrs)
|
||||
c.RateLimiting.Verify(configErrs)
|
||||
if c.RecaptchaEnabled {
|
||||
|
|
@ -108,12 +100,6 @@ func (c *ClientAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
|||
)
|
||||
}
|
||||
}
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
checkURL(configErrs, "client_api.internal_api.listen", string(c.InternalAPI.Listen))
|
||||
checkURL(configErrs, "client_api.internal_api.connect", string(c.InternalAPI.Connect))
|
||||
checkURL(configErrs, "client_api.external_api.listen", string(c.ExternalAPI.Listen))
|
||||
}
|
||||
|
||||
type TURN struct {
|
||||
|
|
|
|||
|
|
@ -1,13 +1,12 @@
|
|||
package config
|
||||
|
||||
import "github.com/matrix-org/gomatrixserverlib"
|
||||
import (
|
||||
"github.com/matrix-org/gomatrixserverlib"
|
||||
)
|
||||
|
||||
type FederationAPI struct {
|
||||
Matrix *Global `yaml:"-"`
|
||||
|
||||
InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
|
||||
ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
|
||||
|
||||
// The database stores information used by the federation destination queues to
|
||||
// send transactions to remote servers.
|
||||
Database DatabaseOptions `yaml:"database,omitempty"`
|
||||
|
|
@ -42,12 +41,6 @@ type FederationAPI struct {
|
|||
}
|
||||
|
||||
func (c *FederationAPI) Defaults(opts DefaultOpts) {
|
||||
if !opts.Monolithic {
|
||||
c.InternalAPI.Listen = "http://localhost:7772"
|
||||
c.InternalAPI.Connect = "http://localhost:7772"
|
||||
c.ExternalAPI.Listen = "http://[::]:8072"
|
||||
c.Database.Defaults(10)
|
||||
}
|
||||
c.FederationMaxRetries = 16
|
||||
c.P2PFederationRetriesUntilAssumedOffline = 1
|
||||
c.DisableTLSValidation = false
|
||||
|
|
@ -68,22 +61,16 @@ func (c *FederationAPI) Defaults(opts DefaultOpts) {
|
|||
},
|
||||
},
|
||||
}
|
||||
if !opts.Monolithic {
|
||||
if !opts.SingleDatabase {
|
||||
c.Database.ConnectionString = "file:federationapi.db"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *FederationAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
func (c *FederationAPI) Verify(configErrs *ConfigErrors) {
|
||||
if c.Matrix.DatabaseOptions.ConnectionString == "" {
|
||||
checkNotEmpty(configErrs, "federation_api.database.connection_string", string(c.Database.ConnectionString))
|
||||
}
|
||||
checkURL(configErrs, "federation_api.external_api.listen", string(c.ExternalAPI.Listen))
|
||||
checkURL(configErrs, "federation_api.internal_api.listen", string(c.InternalAPI.Listen))
|
||||
checkURL(configErrs, "federation_api.internal_api.connect", string(c.InternalAPI.Connect))
|
||||
}
|
||||
|
||||
// The config for setting a proxy to use for server->server requests
|
||||
|
|
|
|||
|
|
@ -38,7 +38,6 @@ type Global struct {
|
|||
// component does not specify any database options of its own, then this pool of
|
||||
// connections will be used instead. This way we don't have to manage connection
|
||||
// counts on a per-component basis, but can instead do it for the entire monolith.
|
||||
// In a polylith deployment, this will be ignored.
|
||||
DatabaseOptions DatabaseOptions `yaml:"database,omitempty"`
|
||||
|
||||
// The server name to delegate server-server communications to, with optional port
|
||||
|
|
@ -93,7 +92,7 @@ func (c *Global) Defaults(opts DefaultOpts) {
|
|||
}
|
||||
}
|
||||
c.KeyValidityPeriod = time.Hour * 24 * 7
|
||||
if opts.Monolithic {
|
||||
if opts.SingleDatabase {
|
||||
c.DatabaseOptions.Defaults(90)
|
||||
}
|
||||
c.JetStream.Defaults(opts)
|
||||
|
|
@ -105,7 +104,7 @@ func (c *Global) Defaults(opts DefaultOpts) {
|
|||
c.Cache.Defaults()
|
||||
}
|
||||
|
||||
func (c *Global) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
func (c *Global) Verify(configErrs *ConfigErrors) {
|
||||
checkNotEmpty(configErrs, "global.server_name", string(c.ServerName))
|
||||
checkNotEmpty(configErrs, "global.private_key", string(c.PrivateKeyPath))
|
||||
|
||||
|
|
@ -113,13 +112,13 @@ func (c *Global) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
|||
v.Verify(configErrs)
|
||||
}
|
||||
|
||||
c.JetStream.Verify(configErrs, isMonolith)
|
||||
c.Metrics.Verify(configErrs, isMonolith)
|
||||
c.Sentry.Verify(configErrs, isMonolith)
|
||||
c.DNSCache.Verify(configErrs, isMonolith)
|
||||
c.ServerNotices.Verify(configErrs, isMonolith)
|
||||
c.ReportStats.Verify(configErrs, isMonolith)
|
||||
c.Cache.Verify(configErrs, isMonolith)
|
||||
c.JetStream.Verify(configErrs)
|
||||
c.Metrics.Verify(configErrs)
|
||||
c.Sentry.Verify(configErrs)
|
||||
c.DNSCache.Verify(configErrs)
|
||||
c.ServerNotices.Verify(configErrs)
|
||||
c.ReportStats.Verify(configErrs)
|
||||
c.Cache.Verify(configErrs)
|
||||
}
|
||||
|
||||
func (c *Global) IsLocalServerName(serverName gomatrixserverlib.ServerName) bool {
|
||||
|
|
@ -267,7 +266,7 @@ func (c *Metrics) Defaults(opts DefaultOpts) {
|
|||
}
|
||||
}
|
||||
|
||||
func (c *Metrics) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
func (c *Metrics) Verify(configErrs *ConfigErrors) {
|
||||
}
|
||||
|
||||
// ServerNotices defines the configuration used for sending server notices
|
||||
|
|
@ -293,7 +292,7 @@ func (c *ServerNotices) Defaults(opts DefaultOpts) {
|
|||
}
|
||||
}
|
||||
|
||||
func (c *ServerNotices) Verify(errors *ConfigErrors, isMonolith bool) {}
|
||||
func (c *ServerNotices) Verify(errors *ConfigErrors) {}
|
||||
|
||||
type Cache struct {
|
||||
EstimatedMaxSize DataUnit `yaml:"max_size_estimated"`
|
||||
|
|
@ -305,7 +304,7 @@ func (c *Cache) Defaults() {
|
|||
c.MaxAge = time.Hour
|
||||
}
|
||||
|
||||
func (c *Cache) Verify(errors *ConfigErrors, isMonolith bool) {
|
||||
func (c *Cache) Verify(errors *ConfigErrors) {
|
||||
checkPositive(errors, "max_size_estimated", int64(c.EstimatedMaxSize))
|
||||
}
|
||||
|
||||
|
|
@ -323,7 +322,7 @@ func (c *ReportStats) Defaults() {
|
|||
c.Endpoint = "https://matrix.org/report-usage-stats/push"
|
||||
}
|
||||
|
||||
func (c *ReportStats) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
func (c *ReportStats) Verify(configErrs *ConfigErrors) {
|
||||
if c.Enabled {
|
||||
checkNotEmpty(configErrs, "global.report_stats.endpoint", c.Endpoint)
|
||||
}
|
||||
|
|
@ -344,7 +343,7 @@ func (c *Sentry) Defaults() {
|
|||
c.Enabled = false
|
||||
}
|
||||
|
||||
func (c *Sentry) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
func (c *Sentry) Verify(configErrs *ConfigErrors) {
|
||||
}
|
||||
|
||||
type DatabaseOptions struct {
|
||||
|
|
@ -364,8 +363,7 @@ func (c *DatabaseOptions) Defaults(conns int) {
|
|||
c.ConnMaxLifetimeSeconds = -1
|
||||
}
|
||||
|
||||
func (c *DatabaseOptions) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
}
|
||||
func (c *DatabaseOptions) Verify(configErrs *ConfigErrors) {}
|
||||
|
||||
// MaxIdleConns returns maximum idle connections to the DB
|
||||
func (c DatabaseOptions) MaxIdleConns() int {
|
||||
|
|
@ -397,7 +395,7 @@ func (c *DNSCacheOptions) Defaults() {
|
|||
c.CacheLifetime = time.Minute * 5
|
||||
}
|
||||
|
||||
func (c *DNSCacheOptions) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
func (c *DNSCacheOptions) Verify(configErrs *ConfigErrors) {
|
||||
checkPositive(configErrs, "cache_size", int64(c.CacheSize))
|
||||
checkPositive(configErrs, "cache_lifetime", int64(c.CacheLifetime))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -41,11 +41,4 @@ func (c *JetStream) Defaults(opts DefaultOpts) {
|
|||
}
|
||||
}
|
||||
|
||||
func (c *JetStream) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
// If we are running in a polylith deployment then we need at least
|
||||
// one NATS JetStream server to talk to.
|
||||
checkNotZero(configErrs, "global.jetstream.addresses", int64(len(c.Addresses)))
|
||||
}
|
||||
func (c *JetStream) Verify(configErrs *ConfigErrors) {}
|
||||
|
|
|
|||
|
|
@ -3,31 +3,19 @@ package config
|
|||
type KeyServer struct {
|
||||
Matrix *Global `yaml:"-"`
|
||||
|
||||
InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
|
||||
|
||||
Database DatabaseOptions `yaml:"database,omitempty"`
|
||||
}
|
||||
|
||||
func (c *KeyServer) Defaults(opts DefaultOpts) {
|
||||
if !opts.Monolithic {
|
||||
c.InternalAPI.Listen = "http://localhost:7779"
|
||||
c.InternalAPI.Connect = "http://localhost:7779"
|
||||
c.Database.Defaults(10)
|
||||
}
|
||||
if opts.Generate {
|
||||
if !opts.Monolithic {
|
||||
if !opts.SingleDatabase {
|
||||
c.Database.ConnectionString = "file:keyserver.db"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *KeyServer) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
func (c *KeyServer) Verify(configErrs *ConfigErrors) {
|
||||
if c.Matrix.DatabaseOptions.ConnectionString == "" {
|
||||
checkNotEmpty(configErrs, "key_server.database.connection_string", string(c.Database.ConnectionString))
|
||||
}
|
||||
checkURL(configErrs, "key_server.internal_api.listen", string(c.InternalAPI.Listen))
|
||||
checkURL(configErrs, "key_server.internal_api.connect", string(c.InternalAPI.Connect))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,9 +7,6 @@ import (
|
|||
type MediaAPI struct {
|
||||
Matrix *Global `yaml:"-"`
|
||||
|
||||
InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
|
||||
ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
|
||||
|
||||
// The MediaAPI database stores information about files uploaded and downloaded
|
||||
// by local users. It is only accessed by the MediaAPI.
|
||||
Database DatabaseOptions `yaml:"database,omitempty"`
|
||||
|
|
@ -39,12 +36,6 @@ type MediaAPI struct {
|
|||
var DefaultMaxFileSizeBytes = FileSizeBytes(10485760)
|
||||
|
||||
func (c *MediaAPI) Defaults(opts DefaultOpts) {
|
||||
if !opts.Monolithic {
|
||||
c.InternalAPI.Listen = "http://localhost:7774"
|
||||
c.InternalAPI.Connect = "http://localhost:7774"
|
||||
c.ExternalAPI.Listen = "http://[::]:8074"
|
||||
c.Database.Defaults(5)
|
||||
}
|
||||
c.MaxFileSizeBytes = DefaultMaxFileSizeBytes
|
||||
c.MaxThumbnailGenerators = 10
|
||||
if opts.Generate {
|
||||
|
|
@ -65,14 +56,14 @@ func (c *MediaAPI) Defaults(opts DefaultOpts) {
|
|||
ResizeMethod: "scale",
|
||||
},
|
||||
}
|
||||
if !opts.Monolithic {
|
||||
if !opts.SingleDatabase {
|
||||
c.Database.ConnectionString = "file:mediaapi.db"
|
||||
}
|
||||
c.BasePath = "./media_store"
|
||||
}
|
||||
}
|
||||
|
||||
func (c *MediaAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
func (c *MediaAPI) Verify(configErrs *ConfigErrors) {
|
||||
checkNotEmpty(configErrs, "media_api.base_path", string(c.BasePath))
|
||||
checkPositive(configErrs, "media_api.max_file_size_bytes", int64(c.MaxFileSizeBytes))
|
||||
checkPositive(configErrs, "media_api.max_thumbnail_generators", int64(c.MaxThumbnailGenerators))
|
||||
|
|
@ -81,13 +72,8 @@ func (c *MediaAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
|||
checkPositive(configErrs, fmt.Sprintf("media_api.thumbnail_sizes[%d].width", i), int64(size.Width))
|
||||
checkPositive(configErrs, fmt.Sprintf("media_api.thumbnail_sizes[%d].height", i), int64(size.Height))
|
||||
}
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
|
||||
if c.Matrix.DatabaseOptions.ConnectionString == "" {
|
||||
checkNotEmpty(configErrs, "media_api.database.connection_string", string(c.Database.ConnectionString))
|
||||
}
|
||||
checkURL(configErrs, "media_api.internal_api.listen", string(c.InternalAPI.Listen))
|
||||
checkURL(configErrs, "media_api.internal_api.connect", string(c.InternalAPI.Connect))
|
||||
checkURL(configErrs, "media_api.external_api.listen", string(c.ExternalAPI.Listen))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -14,11 +14,8 @@ type MSCs struct {
|
|||
}
|
||||
|
||||
func (c *MSCs) Defaults(opts DefaultOpts) {
|
||||
if !opts.Monolithic {
|
||||
c.Database.Defaults(5)
|
||||
}
|
||||
if opts.Generate {
|
||||
if !opts.Monolithic {
|
||||
if !opts.SingleDatabase {
|
||||
c.Database.ConnectionString = "file:mscs.db"
|
||||
}
|
||||
}
|
||||
|
|
@ -34,10 +31,7 @@ func (c *MSCs) Enabled(msc string) bool {
|
|||
return false
|
||||
}
|
||||
|
||||
func (c *MSCs) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
func (c *MSCs) Verify(configErrs *ConfigErrors) {
|
||||
if c.Matrix.DatabaseOptions.ConnectionString == "" {
|
||||
checkNotEmpty(configErrs, "mscs.database.connection_string", string(c.Database.ConnectionString))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,36 +17,21 @@ package config
|
|||
type RelayAPI struct {
|
||||
Matrix *Global `yaml:"-"`
|
||||
|
||||
InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
|
||||
ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
|
||||
|
||||
// The database stores information used by the relay queue to
|
||||
// forward transactions to remote servers.
|
||||
Database DatabaseOptions `yaml:"database,omitempty"`
|
||||
}
|
||||
|
||||
func (c *RelayAPI) Defaults(opts DefaultOpts) {
|
||||
if !opts.Monolithic {
|
||||
c.InternalAPI.Listen = "http://localhost:7775"
|
||||
c.InternalAPI.Connect = "http://localhost:7775"
|
||||
c.ExternalAPI.Listen = "http://[::]:8075"
|
||||
c.Database.Defaults(10)
|
||||
}
|
||||
if opts.Generate {
|
||||
if !opts.Monolithic {
|
||||
if !opts.SingleDatabase {
|
||||
c.Database.ConnectionString = "file:relayapi.db"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *RelayAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
func (c *RelayAPI) Verify(configErrs *ConfigErrors) {
|
||||
if c.Matrix.DatabaseOptions.ConnectionString == "" {
|
||||
checkNotEmpty(configErrs, "relay_api.database.connection_string", string(c.Database.ConnectionString))
|
||||
}
|
||||
checkURL(configErrs, "relay_api.external_api.listen", string(c.ExternalAPI.Listen))
|
||||
checkURL(configErrs, "relay_api.internal_api.listen", string(c.InternalAPI.Listen))
|
||||
checkURL(configErrs, "relay_api.internal_api.connect", string(c.InternalAPI.Connect))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,31 +3,19 @@ package config
|
|||
type RoomServer struct {
|
||||
Matrix *Global `yaml:"-"`
|
||||
|
||||
InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
|
||||
|
||||
Database DatabaseOptions `yaml:"database,omitempty"`
|
||||
}
|
||||
|
||||
func (c *RoomServer) Defaults(opts DefaultOpts) {
|
||||
if !opts.Monolithic {
|
||||
c.InternalAPI.Listen = "http://localhost:7770"
|
||||
c.InternalAPI.Connect = "http://localhost:7770"
|
||||
c.Database.Defaults(20)
|
||||
}
|
||||
if opts.Generate {
|
||||
if !opts.Monolithic {
|
||||
if !opts.SingleDatabase {
|
||||
c.Database.ConnectionString = "file:roomserver.db"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *RoomServer) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
func (c *RoomServer) Verify(configErrs *ConfigErrors) {
|
||||
if c.Matrix.DatabaseOptions.ConnectionString == "" {
|
||||
checkNotEmpty(configErrs, "room_server.database.connection_string", string(c.Database.ConnectionString))
|
||||
}
|
||||
checkURL(configErrs, "room_server.internal_api.listen", string(c.InternalAPI.Listen))
|
||||
checkURL(configErrs, "room_server.internal_ap.connect", string(c.InternalAPI.Connect))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,9 +3,6 @@ package config
|
|||
type SyncAPI struct {
|
||||
Matrix *Global `yaml:"-"`
|
||||
|
||||
InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
|
||||
ExternalAPI ExternalAPIOptions `yaml:"external_api,omitempty"`
|
||||
|
||||
Database DatabaseOptions `yaml:"database,omitempty"`
|
||||
|
||||
RealIPHeader string `yaml:"real_ip_header"`
|
||||
|
|
@ -14,31 +11,19 @@ type SyncAPI struct {
|
|||
}
|
||||
|
||||
func (c *SyncAPI) Defaults(opts DefaultOpts) {
|
||||
if !opts.Monolithic {
|
||||
c.InternalAPI.Listen = "http://localhost:7773"
|
||||
c.InternalAPI.Connect = "http://localhost:7773"
|
||||
c.ExternalAPI.Listen = "http://localhost:8073"
|
||||
c.Database.Defaults(20)
|
||||
}
|
||||
c.Fulltext.Defaults(opts)
|
||||
if opts.Generate {
|
||||
if !opts.Monolithic {
|
||||
if !opts.SingleDatabase {
|
||||
c.Database.ConnectionString = "file:syncapi.db"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *SyncAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
c.Fulltext.Verify(configErrs, isMonolith)
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
func (c *SyncAPI) Verify(configErrs *ConfigErrors) {
|
||||
c.Fulltext.Verify(configErrs)
|
||||
if c.Matrix.DatabaseOptions.ConnectionString == "" {
|
||||
checkNotEmpty(configErrs, "sync_api.database", string(c.Database.ConnectionString))
|
||||
}
|
||||
checkURL(configErrs, "sync_api.internal_api.listen", string(c.InternalAPI.Listen))
|
||||
checkURL(configErrs, "sync_api.internal_api.connect", string(c.InternalAPI.Connect))
|
||||
checkURL(configErrs, "sync_api.external_api.listen", string(c.ExternalAPI.Listen))
|
||||
}
|
||||
|
||||
type Fulltext struct {
|
||||
|
|
@ -54,7 +39,7 @@ func (f *Fulltext) Defaults(opts DefaultOpts) {
|
|||
f.Language = "en"
|
||||
}
|
||||
|
||||
func (f *Fulltext) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
func (f *Fulltext) Verify(configErrs *ConfigErrors) {
|
||||
if !f.Enabled {
|
||||
return
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,14 +30,13 @@ func TestLoadConfigRelative(t *testing.T) {
|
|||
"/my/config/dir/matrix_key.pem": testKey,
|
||||
"/my/config/dir/tls_cert.pem": testCert,
|
||||
}.readFile,
|
||||
false,
|
||||
)
|
||||
if err != nil {
|
||||
t.Error("failed to load config:", err)
|
||||
}
|
||||
|
||||
configErrors := &ConfigErrors{}
|
||||
cfg.Verify(configErrors, false)
|
||||
cfg.Verify(configErrors)
|
||||
if len(*configErrors) > 0 {
|
||||
for _, err := range *configErrors {
|
||||
logrus.Errorf("Configuration error: %s", err)
|
||||
|
|
@ -81,9 +80,6 @@ global:
|
|||
jetstream:
|
||||
addresses: ["test"]
|
||||
app_service_api:
|
||||
internal_api:
|
||||
listen: http://localhost:7777
|
||||
connect: http://localhost:7777
|
||||
database:
|
||||
connection_string: file:appservice.db
|
||||
max_open_conns: 100
|
||||
|
|
@ -91,11 +87,6 @@ app_service_api:
|
|||
conn_max_lifetime: -1
|
||||
config_files: []
|
||||
client_api:
|
||||
internal_api:
|
||||
listen: http://localhost:7771
|
||||
connect: http://localhost:7771
|
||||
external_api:
|
||||
listen: http://[::]:8071
|
||||
registration_disabled: true
|
||||
registration_shared_secret: ""
|
||||
enable_registration_captcha: false
|
||||
|
|
@ -109,38 +100,16 @@ client_api:
|
|||
turn_shared_secret: ""
|
||||
turn_username: ""
|
||||
turn_password: ""
|
||||
current_state_server:
|
||||
internal_api:
|
||||
listen: http://localhost:7782
|
||||
connect: http://localhost:7782
|
||||
database:
|
||||
connection_string: file:currentstate.db
|
||||
max_open_conns: 100
|
||||
max_idle_conns: 2
|
||||
conn_max_lifetime: -1
|
||||
federation_api:
|
||||
internal_api:
|
||||
listen: http://localhost:7772
|
||||
connect: http://localhost:7772
|
||||
external_api:
|
||||
listen: http://[::]:8072
|
||||
database:
|
||||
connection_string: file:federationapi.db
|
||||
key_server:
|
||||
internal_api:
|
||||
listen: http://localhost:7779
|
||||
connect: http://localhost:7779
|
||||
database:
|
||||
connection_string: file:keyserver.db
|
||||
max_open_conns: 100
|
||||
max_idle_conns: 2
|
||||
conn_max_lifetime: -1
|
||||
media_api:
|
||||
internal_api:
|
||||
listen: http://localhost:7774
|
||||
connect: http://localhost:7774
|
||||
external_api:
|
||||
listen: http://[::]:8074
|
||||
database:
|
||||
connection_string: file:mediaapi.db
|
||||
max_open_conns: 100
|
||||
|
|
@ -161,18 +130,12 @@ media_api:
|
|||
height: 480
|
||||
method: scale
|
||||
room_server:
|
||||
internal_api:
|
||||
listen: http://localhost:7770
|
||||
connect: http://localhost:7770
|
||||
database:
|
||||
connection_string: file:roomserver.db
|
||||
max_open_conns: 100
|
||||
max_idle_conns: 2
|
||||
conn_max_lifetime: -1
|
||||
server_key_api:
|
||||
internal_api:
|
||||
listen: http://localhost:7780
|
||||
connect: http://localhost:7780
|
||||
database:
|
||||
connection_string: file:serverkeyapi.db
|
||||
max_open_conns: 100
|
||||
|
|
@ -186,18 +149,12 @@ server_key_api:
|
|||
- key_id: ed25519:a_RXGa
|
||||
public_key: l8Hft5qXKn1vfHrg3p4+W8gELQVo8N13JkluMfmn2sQ
|
||||
sync_api:
|
||||
internal_api:
|
||||
listen: http://localhost:7773
|
||||
connect: http://localhost:7773
|
||||
database:
|
||||
connection_string: file:syncapi.db
|
||||
max_open_conns: 100
|
||||
max_idle_conns: 2
|
||||
conn_max_lifetime: -1
|
||||
user_api:
|
||||
internal_api:
|
||||
listen: http://localhost:7781
|
||||
connect: http://localhost:7781
|
||||
account_database:
|
||||
connection_string: file:userapi_accounts.db
|
||||
max_open_conns: 100
|
||||
|
|
@ -209,11 +166,6 @@ user_api:
|
|||
max_idle_conns: 2
|
||||
conn_max_lifetime: -1
|
||||
relay_api:
|
||||
internal_api:
|
||||
listen: http://localhost:7775
|
||||
connect: http://localhost:7775
|
||||
external_api:
|
||||
listen: http://[::]:8075
|
||||
database:
|
||||
connection_string: file:relayapi.db
|
||||
mscs:
|
||||
|
|
|
|||
|
|
@ -5,8 +5,6 @@ import "golang.org/x/crypto/bcrypt"
|
|||
type UserAPI struct {
|
||||
Matrix *Global `yaml:"-"`
|
||||
|
||||
InternalAPI InternalAPIOptions `yaml:"internal_api,omitempty"`
|
||||
|
||||
// The cost when hashing passwords.
|
||||
BCryptCost int `yaml:"bcrypt_cost"`
|
||||
|
||||
|
|
@ -28,28 +26,18 @@ type UserAPI struct {
|
|||
const DefaultOpenIDTokenLifetimeMS = 3600000 // 60 minutes
|
||||
|
||||
func (c *UserAPI) Defaults(opts DefaultOpts) {
|
||||
if !opts.Monolithic {
|
||||
c.InternalAPI.Listen = "http://localhost:7781"
|
||||
c.InternalAPI.Connect = "http://localhost:7781"
|
||||
c.AccountDatabase.Defaults(10)
|
||||
}
|
||||
c.BCryptCost = bcrypt.DefaultCost
|
||||
c.OpenIDTokenLifetimeMS = DefaultOpenIDTokenLifetimeMS
|
||||
if opts.Generate {
|
||||
if !opts.Monolithic {
|
||||
if !opts.SingleDatabase {
|
||||
c.AccountDatabase.ConnectionString = "file:userapi_accounts.db"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (c *UserAPI) Verify(configErrs *ConfigErrors, isMonolith bool) {
|
||||
func (c *UserAPI) Verify(configErrs *ConfigErrors) {
|
||||
checkPositive(configErrs, "user_api.openid_token_lifetime_ms", c.OpenIDTokenLifetimeMS)
|
||||
if isMonolith { // polylith required configs below
|
||||
return
|
||||
}
|
||||
if c.Matrix.DatabaseOptions.ConnectionString == "" {
|
||||
checkNotEmpty(configErrs, "user_api.account_database.connection_string", string(c.AccountDatabase.ConnectionString))
|
||||
}
|
||||
checkURL(configErrs, "user_api.internal_api.listen", string(c.InternalAPI.Listen))
|
||||
checkURL(configErrs, "user_api.internal_api.connect", string(c.InternalAPI.Connect))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ func ParseFlags(monolith bool) *config.Dendrite {
|
|||
logrus.Fatal("--config must be supplied")
|
||||
}
|
||||
|
||||
cfg, err := config.Load(*configPath, monolith)
|
||||
cfg, err := config.Load(*configPath)
|
||||
|
||||
if err != nil {
|
||||
logrus.Fatalf("Invalid config file: %s", err)
|
||||
|
|
|
|||
|
|
@ -499,7 +499,7 @@ func assertUnsignedChildren(t *testing.T, ev gomatrixserverlib.ClientEvent, relT
|
|||
}
|
||||
|
||||
type testUserAPI struct {
|
||||
userapi.UserInternalAPITrace
|
||||
userapi.UserInternalAPI
|
||||
accessTokens map[string]userapi.Device
|
||||
}
|
||||
|
||||
|
|
@ -516,7 +516,7 @@ func (u *testUserAPI) QueryAccessToken(ctx context.Context, req *userapi.QueryAc
|
|||
type testRoomserverAPI struct {
|
||||
// use a trace API as it implements method stubs so we don't need to have them here.
|
||||
// We'll override the functions we care about.
|
||||
roomserver.RoomserverInternalAPITrace
|
||||
roomserver.RoomserverInternalAPI
|
||||
userToJoinedRooms map[string][]string
|
||||
events map[string]*gomatrixserverlib.HeaderedEvent
|
||||
}
|
||||
|
|
@ -548,8 +548,8 @@ func injectEvents(t *testing.T, userAPI userapi.UserInternalAPI, rsAPI roomserve
|
|||
t.Helper()
|
||||
cfg := &config.Dendrite{}
|
||||
cfg.Defaults(config.DefaultOpts{
|
||||
Generate: true,
|
||||
Monolithic: true,
|
||||
Generate: true,
|
||||
SingleDatabase: true,
|
||||
})
|
||||
cfg.Global.ServerName = "localhost"
|
||||
cfg.MSCs.Database.ConnectionString = "file:msc2836_test.db"
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue