Merge branch 'master' into neilalexander/keydb

appservice/api/query.go

@@ -84,10 +84,10 @@ type AppServiceQueryAPI interface {
 }
 
 // AppServiceRoomAliasExistsPath is the HTTP path for the RoomAliasExists API
-const AppServiceRoomAliasExistsPath = "/api/appservice/RoomAliasExists"
+const AppServiceRoomAliasExistsPath = "/appservice/RoomAliasExists"
 
 // AppServiceUserIDExistsPath is the HTTP path for the UserIDExists API
-const AppServiceUserIDExistsPath = "/api/appservice/UserIDExists"
+const AppServiceUserIDExistsPath = "/appservice/UserIDExists"
 
 // httpAppServiceQueryAPI contains the URL to an appservice query API and a
 // reference to a httpClient used to reach it

appservice/appservice.go

@@ -82,9 +82,7 @@ func SetupAppServiceAPIComponent(
 		Cfg: base.Cfg,
 	}
 
-	if base.EnableHTTPAPIs {
+	appserviceQueryAPI.SetupHTTP(base.InternalAPIMux)
-		appserviceQueryAPI.SetupHTTP(http.DefaultServeMux)
-	}
 
 	consumer := consumers.NewOutputRoomEventConsumer(
 		base.Cfg, base.KafkaConsumer, accountsDB, appserviceDB,
@@ -101,7 +99,7 @@ func SetupAppServiceAPIComponent(
 
 	// Set up HTTP Endpoints
 	routing.Setup(
-		base.APIMux, base.Cfg, rsAPI,
+		base.PublicAPIMux, base.Cfg, rsAPI,
 		accountsDB, federation, transactionsCache,
 	)
 

appservice/query/query.go

@@ -23,6 +23,7 @@ import (
 	"net/url"
 	"time"
 
+	"github.com/gorilla/mux"
 	"github.com/matrix-org/dendrite/appservice/api"
 	"github.com/matrix-org/dendrite/internal"
 	"github.com/matrix-org/dendrite/internal/config"
@@ -182,8 +183,8 @@ func makeHTTPClient() *http.Client {
 
 // SetupHTTP adds the AppServiceQueryPAI handlers to the http.ServeMux. This
 // handles and muxes incoming api requests the to internal AppServiceQueryAPI.
-func (a *AppServiceQueryAPI) SetupHTTP(servMux *http.ServeMux) {
+func (a *AppServiceQueryAPI) SetupHTTP(internalAPIMux *mux.Router) {
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.AppServiceRoomAliasExistsPath,
 		internal.MakeInternalAPI("appserviceRoomAliasExists", func(req *http.Request) util.JSONResponse {
 			var request api.RoomAliasExistsRequest
@@ -197,7 +198,7 @@ func (a *AppServiceQueryAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.AppServiceUserIDExistsPath,
 		internal.MakeInternalAPI("appserviceUserIDExists", func(req *http.Request) util.JSONResponse {
 			var request api.UserIDExistsRequest

appservice/routing/routing.go

@@ -27,7 +27,7 @@ import (
 	"github.com/matrix-org/util"
 )
 
-const pathPrefixApp = "/_matrix/app/v1"
+const pathPrefixApp = "/app/v1"
 
 // Setup registers HTTP handlers with the given ServeMux. It also supplies the given http.Client
 // to clients which need to make outbound HTTP requests.

appservice/storage/storage_wasm.go

@@ -34,7 +34,7 @@ func NewDatabase(
 	case "postgres":
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
+		return sqlite3.NewDatabase(uri.Path)
 	default:
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	}

clientapi/auth/storage/accounts/storage_wasm.go

@@ -36,7 +36,7 @@ func NewDatabase(
 	case "postgres":
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	case "file":
-		return sqlite3.NewDatabase(dataSourceName, serverName)
+		return sqlite3.NewDatabase(uri.Path, serverName)
 	default:
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	}

clientapi/auth/storage/devices/postgres/devices_table.go

@@ -206,9 +206,8 @@ func (s *devicesStatements) selectDeviceByID(
 	ctx context.Context, localpart, deviceID string,
 ) (*authtypes.Device, error) {
 	var dev authtypes.Device
-	var created sql.NullInt64
 	stmt := s.selectDeviceByIDStmt
-	err := stmt.QueryRowContext(ctx, localpart, deviceID).Scan(&created)
+	err := stmt.QueryRowContext(ctx, localpart, deviceID).Scan(&dev.DisplayName)
 	if err == nil {
 		dev.ID = deviceID
 		dev.UserID = userutil.MakeUserID(localpart, s.serverName)
@@ -230,10 +229,17 @@ func (s *devicesStatements) selectDevicesByLocalpart(
 
 	for rows.Next() {
 		var dev authtypes.Device
-		err = rows.Scan(&dev.ID, &dev.DisplayName)
+		var id, displayname sql.NullString
+		err = rows.Scan(&id, &displayname)
 		if err != nil {
 			return devices, err
 		}
+		if id.Valid {
+			dev.ID = id.String
+		}
+		if displayname.Valid {
+			dev.DisplayName = displayname.String
+		}
 		dev.UserID = userutil.MakeUserID(localpart, s.serverName)
 		devices = append(devices, dev)
 	}

clientapi/auth/storage/devices/sqlite3/devices_table.go

@@ -208,9 +208,8 @@ func (s *devicesStatements) selectDeviceByID(
 	ctx context.Context, localpart, deviceID string,
 ) (*authtypes.Device, error) {
 	var dev authtypes.Device
-	var created sql.NullInt64
 	stmt := s.selectDeviceByIDStmt
-	err := stmt.QueryRowContext(ctx, localpart, deviceID).Scan(&created)
+	err := stmt.QueryRowContext(ctx, localpart, deviceID).Scan(&dev.DisplayName)
 	if err == nil {
 		dev.ID = deviceID
 		dev.UserID = userutil.MakeUserID(localpart, s.serverName)
@@ -231,10 +230,17 @@ func (s *devicesStatements) selectDevicesByLocalpart(
 
 	for rows.Next() {
 		var dev authtypes.Device
-		err = rows.Scan(&dev.ID, &dev.DisplayName)
+		var id, displayname sql.NullString
+		err = rows.Scan(&id, &displayname)
 		if err != nil {
 			return devices, err
 		}
+		if id.Valid {
+			dev.ID = id.String
+		}
+		if displayname.Valid {
+			dev.DisplayName = displayname.String
+		}
 		dev.UserID = userutil.MakeUserID(localpart, s.serverName)
 		devices = append(devices, dev)
 	}

clientapi/auth/storage/devices/storage_wasm.go

@@ -36,7 +36,7 @@ func NewDatabase(
 	case "postgres":
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	case "file":
-		return sqlite3.NewDatabase(dataSourceName, serverName)
+		return sqlite3.NewDatabase(uri.Path, serverName)
 	default:
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	}

clientapi/clientapi.go

@@ -65,7 +65,7 @@ func SetupClientAPIComponent(
 	}
 
 	routing.Setup(
-		base.APIMux, base.Cfg, roomserverProducer, rsAPI, asAPI,
+		base.PublicAPIMux, base.Cfg, roomserverProducer, rsAPI, asAPI,
 		accountsDB, deviceDB, federation, *keyRing, userUpdateProducer,
 		syncProducer, eduProducer, transactionsCache, fsAPI,
 	)

clientapi/routing/joinroom.go

@@ -75,6 +75,6 @@ func JoinRoomByIDOrAlias(
 		// TODO: Put the response struct somewhere internal.
 		JSON: struct {
 			RoomID string `json:"room_id"`
-		}{joinReq.RoomIDOrAlias},
+		}{joinRes.RoomID},
 	}
 }

clientapi/routing/routing.go

@@ -36,9 +36,9 @@ import (
 	"github.com/matrix-org/util"
 )
 
-const pathPrefixV1 = "/_matrix/client/api/v1"
+const pathPrefixV1 = "/client/api/v1"
-const pathPrefixR0 = "/_matrix/client/r0"
+const pathPrefixR0 = "/client/r0"
-const pathPrefixUnstable = "/_matrix/client/unstable"
+const pathPrefixUnstable = "/client/unstable"
 
 // Setup registers HTTP handlers with the given ServeMux. It also supplies the given http.Client
 // to clients which need to make outbound HTTP requests.
@@ -47,7 +47,7 @@ const pathPrefixUnstable = "/_matrix/client/unstable"
 // applied:
 // nolint: gocyclo
 func Setup(
-	apiMux *mux.Router, cfg *config.Dendrite,
+	publicAPIMux *mux.Router, cfg *config.Dendrite,
 	producer *producers.RoomserverProducer,
 	rsAPI roomserverAPI.RoomserverInternalAPI,
 	asAPI appserviceAPI.AppServiceQueryAPI,
@@ -62,7 +62,7 @@ func Setup(
 	federationSender federationSenderAPI.FederationSenderInternalAPI,
 ) {
 
-	apiMux.Handle("/_matrix/client/versions",
+	publicAPIMux.Handle("/client/versions",
 		internal.MakeExternalAPI("versions", func(req *http.Request) util.JSONResponse {
 			return util.JSONResponse{
 				Code: http.StatusOK,
@@ -78,9 +78,9 @@ func Setup(
 		}),
 	).Methods(http.MethodGet, http.MethodOptions)
 
-	r0mux := apiMux.PathPrefix(pathPrefixR0).Subrouter()
+	r0mux := publicAPIMux.PathPrefix(pathPrefixR0).Subrouter()
-	v1mux := apiMux.PathPrefix(pathPrefixV1).Subrouter()
+	v1mux := publicAPIMux.PathPrefix(pathPrefixV1).Subrouter()
-	unstableMux := apiMux.PathPrefix(pathPrefixUnstable).Subrouter()
+	unstableMux := publicAPIMux.PathPrefix(pathPrefixUnstable).Subrouter()
 
 	authData := auth.Data{
 		AccountDB:   accountDB,

cmd/client-api-proxy/main.go

@@ -75,7 +75,6 @@ func makeProxy(targetURL string) (*httputil.ReverseProxy, error) {
 			// Pratically this means that any distinction between '%2F' and '/'
 			// in the URL will be lost by the time it reaches the target.
 			path := req.URL.Path
-			path = "api" + path
 			log.WithFields(log.Fields{
 				"path":   path,
 				"url":    targetURL,

cmd/dendrite-demo-libp2p/main.go

@@ -47,7 +47,6 @@ import (
 
 	"github.com/matrix-org/dendrite/eduserver/cache"
 
-	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/sirupsen/logrus"
 )
 
@@ -174,12 +173,13 @@ func main() {
 	publicroomsapi.SetupPublicRoomsAPIComponent(&base.Base, deviceDB, publicRoomsDB, rsAPI, federation, nil) // Check this later
 	syncapi.SetupSyncAPIComponent(&base.Base, deviceDB, accountDB, rsAPI, federation, &cfg)
 
-	httpHandler := internal.WrapHandlerInCORS(base.Base.APIMux)
+	internal.SetupHTTPAPI(
-
+		http.DefaultServeMux,
-	// Set up the API endpoints we handle. /metrics is for prometheus, and is
+		base.Base.PublicAPIMux,
-	// not wrapped by CORS, while everything else is
+		base.Base.InternalAPIMux,
-	http.Handle("/metrics", promhttp.Handler())
+		&cfg,
-	http.Handle("/", httpHandler)
+		base.Base.EnableHTTPAPIs,
+	)
 
 	// Expose the matrix APIs directly rather than putting them under a /api path.
 	go func() {

cmd/dendrite-monolith-server/main.go

@@ -27,6 +27,7 @@ import (
 	"github.com/matrix-org/dendrite/federationsender"
 	"github.com/matrix-org/dendrite/internal"
 	"github.com/matrix-org/dendrite/internal/basecomponent"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/transactions"
 	"github.com/matrix-org/dendrite/keyserver"
 	"github.com/matrix-org/dendrite/mediaapi"
@@ -35,7 +36,6 @@ import (
 	"github.com/matrix-org/dendrite/roomserver"
 	"github.com/matrix-org/dendrite/serverkeyapi"
 	"github.com/matrix-org/dendrite/syncapi"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
 
 	"github.com/sirupsen/logrus"
 )
@@ -45,11 +45,23 @@ var (
 	httpsBindAddr  = flag.String("https-bind-address", ":8448", "The HTTPS listening port for the server")
 	certFile       = flag.String("tls-cert", "", "The PEM formatted X509 certificate to use for TLS")
 	keyFile        = flag.String("tls-key", "", "The PEM private key to use for TLS")
-	enableHTTPAPIs = flag.Bool("api", false, "Expose internal HTTP APIs in monolith mode")
+	enableHTTPAPIs = flag.Bool("api", false, "Use HTTP APIs instead of short-circuiting (warning: exposes API endpoints!)")
 )
 
 func main() {
 	cfg := basecomponent.ParseMonolithFlags()
+	if *enableHTTPAPIs {
+		// If the HTTP APIs are enabled then we need to update the Listen
+		// statements in the configuration so that we know where to find
+		// the API endpoints. They'll listen on the same port as the monolith
+		// itself.
+		addr := config.Address(*httpBindAddr)
+		cfg.Listen.RoomServer = addr
+		cfg.Listen.EDUServer = addr
+		cfg.Listen.AppServiceAPI = addr
+		cfg.Listen.FederationSender = addr
+	}
+
 	base := basecomponent.NewBaseDendrite(cfg, "Monolith", *enableHTTPAPIs)
 	defer base.Close() // nolint: errcheck
 
@@ -62,25 +74,42 @@ func main() {
 	)
 	keyRing := serverKeyAPI.KeyRing()
 
-	rsAPI := roomserver.SetupRoomServerComponent(
+	rsComponent := roomserver.SetupRoomServerComponent(
 		base, keyRing, federation,
 	)
+	rsAPI := rsComponent
+	if base.EnableHTTPAPIs {
+		rsAPI = base.CreateHTTPRoomserverAPIs()
+	}
+
 	eduInputAPI := eduserver.SetupEDUServerComponent(
 		base, cache.New(),
 	)
+	if base.EnableHTTPAPIs {
+		eduInputAPI = base.CreateHTTPEDUServerAPIs()
+	}
+
 	asAPI := appservice.SetupAppServiceAPIComponent(
 		base, accountDB, deviceDB, federation, rsAPI, transactions.New(),
 	)
+	if base.EnableHTTPAPIs {
+		asAPI = base.CreateHTTPAppServiceAPIs()
+	}
+
 	fsAPI := federationsender.SetupFederationSenderComponent(
 		base, federation, rsAPI, keyRing,
 	)
-	rsAPI.SetFederationSenderAPI(fsAPI)
+	if base.EnableHTTPAPIs {
+		fsAPI = base.CreateHTTPFederationSenderAPIs()
+	}
+	rsComponent.SetFederationSenderAPI(fsAPI)
 
 	clientapi.SetupClientAPIComponent(
 		base, deviceDB, accountDB,
 		federation, keyRing, rsAPI,
 		eduInputAPI, asAPI, transactions.New(), fsAPI,
 	)
+
 	keyserver.SetupKeyServerComponent(
 		base, deviceDB, accountDB,
 	)
@@ -94,14 +123,13 @@ func main() {
 	publicroomsapi.SetupPublicRoomsAPIComponent(base, deviceDB, publicRoomsDB, rsAPI, federation, nil)
 	syncapi.SetupSyncAPIComponent(base, deviceDB, accountDB, rsAPI, federation, cfg)
 
-	httpHandler := internal.WrapHandlerInCORS(base.APIMux)
+	internal.SetupHTTPAPI(
-
+		http.DefaultServeMux,
-	// Set up the API endpoints we handle. /metrics is for prometheus, and is
+		base.PublicAPIMux,
-	// not wrapped by CORS, while everything else is
+		base.InternalAPIMux,
-	if cfg.Metrics.Enabled {
+		cfg,
-		http.Handle("/metrics", internal.WrapHandlerInBasicAuth(promhttp.Handler(), cfg.Metrics.BasicAuth))
+		base.EnableHTTPAPIs,
-	}
+	)
-	http.Handle("/", httpHandler)
 
 	// Expose the matrix APIs directly rather than putting them under a /api path.
 	go func() {

cmd/dendritejs/main.go

@@ -164,16 +164,16 @@ func main() {
 	cfg := &config.Dendrite{}
 	cfg.SetDefaults()
 	cfg.Kafka.UseNaffka = true
-	cfg.Database.Account = "file:dendritejs_account.db"
+	cfg.Database.Account = "file:/idb/dendritejs_account.db"
-	cfg.Database.AppService = "file:dendritejs_appservice.db"
+	cfg.Database.AppService = "file:/idb/dendritejs_appservice.db"
-	cfg.Database.Device = "file:dendritejs_device.db"
+	cfg.Database.Device = "file:/idb/dendritejs_device.db"
-	cfg.Database.FederationSender = "file:dendritejs_fedsender.db"
+	cfg.Database.FederationSender = "file:/idb/dendritejs_fedsender.db"
-	cfg.Database.MediaAPI = "file:dendritejs_mediaapi.db"
+	cfg.Database.MediaAPI = "file:/idb/dendritejs_mediaapi.db"
-	cfg.Database.Naffka = "file:dendritejs_naffka.db"
+	cfg.Database.Naffka = "file:/idb/dendritejs_naffka.db"
-	cfg.Database.PublicRoomsAPI = "file:dendritejs_publicrooms.db"
+	cfg.Database.PublicRoomsAPI = "file:/idb/dendritejs_publicrooms.db"
-	cfg.Database.RoomServer = "file:dendritejs_roomserver.db"
+	cfg.Database.RoomServer = "file:/idb/dendritejs_roomserver.db"
-	cfg.Database.ServerKey = "file:dendritejs_serverkey.db"
+	cfg.Database.ServerKey = "file:/idb/dendritejs_serverkey.db"
-	cfg.Database.SyncAPI = "file:dendritejs_syncapi.db"
+	cfg.Database.SyncAPI = "file:/idb/dendritejs_syncapi.db"
 	cfg.Kafka.Topics.UserUpdates = "user_updates"
 	cfg.Kafka.Topics.OutputTypingEvent = "output_typing_event"
 	cfg.Kafka.Topics.OutputClientData = "output_client_data"
@@ -231,9 +231,13 @@ func main() {
 	publicroomsapi.SetupPublicRoomsAPIComponent(base, deviceDB, publicRoomsDB, rsAPI, federation, p2pPublicRoomProvider)
 	syncapi.SetupSyncAPIComponent(base, deviceDB, accountDB, rsAPI, federation, cfg)
 
-	httpHandler := internal.WrapHandlerInCORS(base.APIMux)
+	internal.SetupHTTPAPI(
-
+		http.DefaultServeMux,
-	http.Handle("/", httpHandler)
+		base.PublicAPIMux,
+		base.InternalAPIMux,
+		cfg,
+		base.EnableHTTPAPIs,
+	)
 
 	// Expose the matrix APIs via libp2p-js - for federation traffic
 	if node != nil {

cmd/federation-api-proxy/main.go

@@ -73,7 +73,6 @@ func makeProxy(targetURL string) (*httputil.ReverseProxy, error) {
 			// Pratically this means that any distinction between '%2F' and '/'
 			// in the URL will be lost by the time it reaches the target.
 			path := req.URL.Path
-			path = "api" + path
 			log.WithFields(log.Fields{
 				"path":   path,
 				"url":    targetURL,

eduserver/api/input.go

@@ -55,7 +55,7 @@ type EDUServerInputAPI interface {
 }
 
 // EDUServerInputTypingEventPath is the HTTP path for the InputTypingEvent API.
-const EDUServerInputTypingEventPath = "/api/eduserver/input"
+const EDUServerInputTypingEventPath = "/eduserver/input"
 
 // NewEDUServerInputAPIHTTP creates a EDUServerInputAPI implemented by talking to a HTTP POST API.
 func NewEDUServerInputAPIHTTP(eduServerURL string, httpClient *http.Client) (EDUServerInputAPI, error) {

eduserver/eduserver.go

@@ -13,8 +13,6 @@
 package eduserver
 
 import (
-	"net/http"
-
 	"github.com/matrix-org/dendrite/eduserver/api"
 	"github.com/matrix-org/dendrite/eduserver/cache"
 	"github.com/matrix-org/dendrite/eduserver/input"
@@ -35,9 +33,7 @@ func SetupEDUServerComponent(
 		OutputTypingEventTopic: string(base.Cfg.Kafka.Topics.OutputTypingEvent),
 	}
 
-	if base.EnableHTTPAPIs {
+	inputAPI.SetupHTTP(base.InternalAPIMux)
-		inputAPI.SetupHTTP(http.DefaultServeMux)
-	}
 
 	return inputAPI
 }

eduserver/input/input.go

@@ -19,6 +19,7 @@ import (
 	"time"
 
 	"github.com/Shopify/sarama"
+	"github.com/gorilla/mux"
 	"github.com/matrix-org/dendrite/eduserver/api"
 	"github.com/matrix-org/dendrite/eduserver/cache"
 	"github.com/matrix-org/dendrite/internal"
@@ -90,8 +91,8 @@ func (t *EDUServerInputAPI) sendEvent(ite *api.InputTypingEvent) error {
 }
 
 // SetupHTTP adds the EDUServerInputAPI handlers to the http.ServeMux.
-func (t *EDUServerInputAPI) SetupHTTP(servMux *http.ServeMux) {
+func (t *EDUServerInputAPI) SetupHTTP(internalAPIMux *mux.Router) {
-	servMux.Handle(api.EDUServerInputTypingEventPath,
+	internalAPIMux.Handle(api.EDUServerInputTypingEventPath,
 		internal.MakeInternalAPI("inputTypingEvents", func(req *http.Request) util.JSONResponse {
 			var request api.InputTypingEventRequest
 			var response api.InputTypingEventResponse

federationapi/federationapi.go

@@ -44,7 +44,7 @@ func SetupFederationAPIComponent(
 	roomserverProducer := producers.NewRoomserverProducer(rsAPI)
 
 	routing.Setup(
-		base.APIMux, base.Cfg, rsAPI, asAPI, roomserverProducer,
+		base.PublicAPIMux, base.Cfg, rsAPI, asAPI, roomserverProducer,
 		eduProducer, federationSenderAPI, *keyRing,
 		federation, accountsDB, deviceDB,
 	)

federationapi/routing/routing.go

@@ -31,9 +31,9 @@ import (
 )
 
 const (
-	pathPrefixV2Keys       = "/_matrix/key/v2"
+	pathPrefixV2Keys       = "/key/v2"
-	pathPrefixV1Federation = "/_matrix/federation/v1"
+	pathPrefixV1Federation = "/federation/v1"
-	pathPrefixV2Federation = "/_matrix/federation/v2"
+	pathPrefixV2Federation = "/federation/v2"
 )
 
 // Setup registers HTTP handlers with the given ServeMux.
@@ -42,7 +42,7 @@ const (
 // applied:
 // nolint: gocyclo
 func Setup(
-	apiMux *mux.Router,
+	publicAPIMux *mux.Router,
 	cfg *config.Dendrite,
 	rsAPI roomserverAPI.RoomserverInternalAPI,
 	asAPI appserviceAPI.AppServiceQueryAPI,
@@ -54,9 +54,9 @@ func Setup(
 	accountDB accounts.Database,
 	deviceDB devices.Database,
 ) {
-	v2keysmux := apiMux.PathPrefix(pathPrefixV2Keys).Subrouter()
+	v2keysmux := publicAPIMux.PathPrefix(pathPrefixV2Keys).Subrouter()
-	v1fedmux := apiMux.PathPrefix(pathPrefixV1Federation).Subrouter()
+	v1fedmux := publicAPIMux.PathPrefix(pathPrefixV1Federation).Subrouter()
-	v2fedmux := apiMux.PathPrefix(pathPrefixV2Federation).Subrouter()
+	v2fedmux := publicAPIMux.PathPrefix(pathPrefixV2Federation).Subrouter()
 
 	localKeys := internal.MakeExternalAPI("localkeys", func(req *http.Request) util.JSONResponse {
 		return LocalKeys(cfg)

federationsender/api/perform.go

@@ -11,13 +11,13 @@ import (
 
 const (
 	// FederationSenderPerformJoinRequestPath is the HTTP path for the PerformJoinRequest API.
-	FederationSenderPerformDirectoryLookupRequestPath = "/api/federationsender/performDirectoryLookup"
+	FederationSenderPerformDirectoryLookupRequestPath = "/federationsender/performDirectoryLookup"
 
 	// FederationSenderPerformJoinRequestPath is the HTTP path for the PerformJoinRequest API.
-	FederationSenderPerformJoinRequestPath = "/api/federationsender/performJoinRequest"
+	FederationSenderPerformJoinRequestPath = "/federationsender/performJoinRequest"
 
 	// FederationSenderPerformLeaveRequestPath is the HTTP path for the PerformLeaveRequest API.
-	FederationSenderPerformLeaveRequestPath = "/api/federationsender/performLeaveRequest"
+	FederationSenderPerformLeaveRequestPath = "/federationsender/performLeaveRequest"
 )
 
 type PerformDirectoryLookupRequest struct {

federationsender/api/query.go

@@ -11,10 +11,10 @@ import (
 )
 
 // FederationSenderQueryJoinedHostsInRoomPath is the HTTP path for the QueryJoinedHostsInRoom API.
-const FederationSenderQueryJoinedHostsInRoomPath = "/api/federationsender/queryJoinedHostsInRoom"
+const FederationSenderQueryJoinedHostsInRoomPath = "/federationsender/queryJoinedHostsInRoom"
 
 // FederationSenderQueryJoinedHostServerNamesInRoomPath is the HTTP path for the QueryJoinedHostServerNamesInRoom API.
-const FederationSenderQueryJoinedHostServerNamesInRoomPath = "/api/federationsender/queryJoinedHostServerNamesInRoom"
+const FederationSenderQueryJoinedHostServerNamesInRoomPath = "/federationsender/queryJoinedHostServerNamesInRoom"
 
 // QueryJoinedHostsInRoomRequest is a request to QueryJoinedHostsInRoom
 type QueryJoinedHostsInRoomRequest struct {

federationsender/federationsender.go

@@ -15,8 +15,6 @@
 package federationsender
 
 import (
-	"net/http"
-
 	"github.com/matrix-org/dendrite/federationsender/api"
 	"github.com/matrix-org/dendrite/federationsender/consumers"
 	"github.com/matrix-org/dendrite/federationsender/internal"
@@ -72,9 +70,7 @@ func SetupFederationSenderComponent(
 		statistics,
 	)
 
-	if base.EnableHTTPAPIs {
+	queryAPI.SetupHTTP(base.InternalAPIMux)
-		queryAPI.SetupHTTP(http.DefaultServeMux)
-	}
 
 	return queryAPI
 }

federationsender/internal/api.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"net/http"
 
+	"github.com/gorilla/mux"
 	"github.com/matrix-org/dendrite/federationsender/api"
 	"github.com/matrix-org/dendrite/federationsender/producers"
 	"github.com/matrix-org/dendrite/federationsender/storage"
@@ -43,8 +44,8 @@ func NewFederationSenderInternalAPI(
 }
 
 // SetupHTTP adds the FederationSenderInternalAPI handlers to the http.ServeMux.
-func (f *FederationSenderInternalAPI) SetupHTTP(servMux *http.ServeMux) {
+func (f *FederationSenderInternalAPI) SetupHTTP(internalAPIMux *mux.Router) {
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.FederationSenderQueryJoinedHostsInRoomPath,
 		internal.MakeInternalAPI("QueryJoinedHostsInRoom", func(req *http.Request) util.JSONResponse {
 			var request api.QueryJoinedHostsInRoomRequest
@@ -58,7 +59,7 @@ func (f *FederationSenderInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.FederationSenderQueryJoinedHostServerNamesInRoomPath,
 		internal.MakeInternalAPI("QueryJoinedHostServerNamesInRoom", func(req *http.Request) util.JSONResponse {
 			var request api.QueryJoinedHostServerNamesInRoomRequest
@@ -72,7 +73,7 @@ func (f *FederationSenderInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(api.FederationSenderPerformJoinRequestPath,
+	internalAPIMux.Handle(api.FederationSenderPerformJoinRequestPath,
 		internal.MakeInternalAPI("PerformJoinRequest", func(req *http.Request) util.JSONResponse {
 			var request api.PerformJoinRequest
 			var response api.PerformJoinResponse
@@ -85,7 +86,7 @@ func (f *FederationSenderInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(api.FederationSenderPerformLeaveRequestPath,
+	internalAPIMux.Handle(api.FederationSenderPerformLeaveRequestPath,
 		internal.MakeInternalAPI("PerformLeaveRequest", func(req *http.Request) util.JSONResponse {
 			var request api.PerformLeaveRequest
 			var response api.PerformLeaveResponse
@@ -98,4 +99,17 @@ func (f *FederationSenderInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
+	internalAPIMux.Handle(api.FederationSenderPerformDirectoryLookupRequestPath,
+		internal.MakeInternalAPI("PerformDirectoryLookupRequest", func(req *http.Request) util.JSONResponse {
+			var request api.PerformDirectoryLookupRequest
+			var response api.PerformDirectoryLookupResponse
+			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
+				return util.MessageResponse(http.StatusBadRequest, err.Error())
+			}
+			if err := f.PerformDirectoryLookup(req.Context(), &request, &response); err != nil {
+				return util.ErrorResponse(err)
+			}
+			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
+		}),
+	)
 }

federationsender/storage/storage_wasm.go

@@ -33,7 +33,7 @@ func NewDatabase(
 	}
 	switch uri.Scheme {
 	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
+		return sqlite3.NewDatabase(uri.Path)
 	case "postgres":
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	default:

go.mod

@@ -16,7 +16,7 @@ require (
 	github.com/libp2p/go-libp2p-record v0.1.2
 	github.com/matrix-org/dugong v0.0.0-20171220115018-ea0a4690a0d5
 	github.com/matrix-org/go-http-js-libp2p v0.0.0-20200518170932-783164aeeda4
-	github.com/matrix-org/go-sqlite3-js v0.0.0-20200326102434-98eda28055bd
+	github.com/matrix-org/go-sqlite3-js v0.0.0-20200522092705-bc8506ccbcf3
 	github.com/matrix-org/gomatrix v0.0.0-20190528120928-7df988a63f26
 	github.com/matrix-org/gomatrixserverlib v0.0.0-20200521102632-2a81324a04ae
 	github.com/matrix-org/naffka v0.0.0-20200422140631-181f1ee7401f

go.sum

@@ -354,6 +354,8 @@ github.com/matrix-org/go-http-js-libp2p v0.0.0-20200518170932-783164aeeda4 h1:eq
 github.com/matrix-org/go-http-js-libp2p v0.0.0-20200518170932-783164aeeda4/go.mod h1:3WluEZ9QXSwU30tWYqktnpC1x9mwZKx1r8uAv8Iq+a4=
 github.com/matrix-org/go-sqlite3-js v0.0.0-20200326102434-98eda28055bd h1:C1FV4dRKF1uuGK8UH01+IoW6zZpfsTV1MvQimZvt418=
 github.com/matrix-org/go-sqlite3-js v0.0.0-20200326102434-98eda28055bd/go.mod h1:e+cg2q7C7yE5QnAXgzo512tgFh1RbQLC0+jozuegKgo=
+github.com/matrix-org/go-sqlite3-js v0.0.0-20200522092705-bc8506ccbcf3 h1:Yb+Wlf/iHhWlLWd+kCgG+Fsg4Dc+xBl7hptfK7lD0zY=
+github.com/matrix-org/go-sqlite3-js v0.0.0-20200522092705-bc8506ccbcf3/go.mod h1:e+cg2q7C7yE5QnAXgzo512tgFh1RbQLC0+jozuegKgo=
 github.com/matrix-org/gomatrix v0.0.0-20190528120928-7df988a63f26 h1:Hr3zjRsq2bhrnp3Ky1qgx/fzCtCALOoGYylh2tpS9K4=
 github.com/matrix-org/gomatrix v0.0.0-20190528120928-7df988a63f26/go.mod h1:3fxX6gUjWyI/2Bt7J1OLhpCzOfO/bB3AiX0cJtEKud0=
 github.com/matrix-org/gomatrixserverlib v0.0.0-20200521102632-2a81324a04ae h1:kFMh2aU3pMCkVCUeH57rtgm05XImbxKOHFYeUp80RCk=

internal/basecomponent/base.go

@@ -22,6 +22,7 @@ import (
 	"time"
 
 	"github.com/matrix-org/dendrite/internal/caching"
+	"github.com/matrix-org/dendrite/internal/httpapis"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/naffka"
@@ -53,8 +54,9 @@ type BaseDendrite struct {
 	componentName string
 	tracerCloser  io.Closer
 
-	// APIMux should be used to register new public matrix api endpoints
+	// PublicAPIMux should be used to register new public matrix api endpoints
-	APIMux         *mux.Router
+	PublicAPIMux   *mux.Router
+	InternalAPIMux *mux.Router
 	EnableHTTPAPIs bool
 	httpClient     *http.Client
 	Cfg            *config.Dendrite
@@ -92,13 +94,15 @@ func NewBaseDendrite(cfg *config.Dendrite, componentName string, enableHTTPAPIs
 		logrus.WithError(err).Warnf("Failed to create cache")
 	}
 
+	httpmux := mux.NewRouter()
 	return &BaseDendrite{
 		componentName:  componentName,
 		EnableHTTPAPIs: enableHTTPAPIs,
 		tracerCloser:   closer,
 		Cfg:            cfg,
 		ImmutableCache: cache,
-		APIMux:         mux.NewRouter().UseEncodedPath(),
+		PublicAPIMux:   httpmux.PathPrefix(httpapis.PublicPathPrefix).Subrouter().UseEncodedPath(),
+		InternalAPIMux: httpmux.PathPrefix(httpapis.InternalPathPrefix).Subrouter().UseEncodedPath(),
 		httpClient:     &http.Client{Timeout: HTTPClientTimeout},
 		KafkaConsumer:  kafkaConsumer,
 		KafkaProducer:  kafkaProducer,
@@ -211,7 +215,13 @@ func (b *BaseDendrite) SetupAndServeHTTP(bindaddr string, listenaddr string) {
 		WriteTimeout: HTTPServerTimeout,
 	}
 
-	internal.SetupHTTPAPI(http.DefaultServeMux, internal.WrapHandlerInCORS(b.APIMux), b.Cfg)
+	internal.SetupHTTPAPI(
+		http.DefaultServeMux,
+		b.PublicAPIMux,
+		b.InternalAPIMux,
+		b.Cfg,
+		b.EnableHTTPAPIs,
+	)
 	logrus.Infof("Starting %s server on %s", b.componentName, serv.Addr)
 
 	err := serv.ListenAndServe()
@@ -245,7 +255,15 @@ func setupNaffka(cfg *config.Dendrite) (sarama.Consumer, sarama.SyncProducer) {
 
 	uri, err := url.Parse(string(cfg.Database.Naffka))
 	if err != nil || uri.Scheme == "file" {
-		db, err = sqlutil.Open(internal.SQLiteDriverName(), string(cfg.Database.Naffka), nil)
+		var cs string
+		if uri.Opaque != "" { // file:filename.db
+			cs = uri.Opaque
+		} else if uri.Path != "" { // file:///path/to/filename.db
+			cs = uri.Path
+		} else {
+			logrus.Panic("file uri has no filename")
+		}
+		db, err = sqlutil.Open(internal.SQLiteDriverName(), cs, nil)
 		if err != nil {
 			logrus.WithError(err).Panic("Failed to open naffka database")
 		}

internal/http/http.go

@@ -6,7 +6,10 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"net/url"
+	"strings"
 
+	"github.com/matrix-org/dendrite/internal/httpapis"
 	opentracing "github.com/opentracing/opentracing-go"
 	"github.com/opentracing/opentracing-go/ext"
 )
@@ -21,6 +24,14 @@ func PostJSON(
 		return err
 	}
 
+	parsedAPIURL, err := url.Parse(apiURL)
+	if err != nil {
+		return err
+	}
+
+	parsedAPIURL.Path = httpapis.InternalPathPrefix + strings.TrimLeft(parsedAPIURL.Path, "/")
+	apiURL = parsedAPIURL.String()
+
 	req, err := http.NewRequest(http.MethodPost, apiURL, bytes.NewReader(jsonBytes))
 	if err != nil {
 		return err
@@ -48,10 +59,10 @@ func PostJSON(
 		var errorBody struct {
 			Message string `json:"message"`
 		}
-		if err = json.NewDecoder(res.Body).Decode(&errorBody); err != nil {
+		if msgerr := json.NewDecoder(res.Body).Decode(&errorBody); msgerr == nil {
-			return err
+			return fmt.Errorf("Internal API: %d from %s: %s", res.StatusCode, apiURL, errorBody.Message)
 		}
-		return fmt.Errorf("api: %d: %s", res.StatusCode, errorBody.Message)
+		return fmt.Errorf("Internal API: %d from %s", res.StatusCode, apiURL)
 	}
 	return json.NewDecoder(res.Body).Decode(response)
 }

internal/httpapi.go

@@ -9,9 +9,11 @@ import (
 	"strings"
 	"time"
 
+	"github.com/gorilla/mux"
 	"github.com/matrix-org/dendrite/clientapi/auth"
 	"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
 	"github.com/matrix-org/dendrite/internal/config"
+	"github.com/matrix-org/dendrite/internal/httpapis"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/util"
 	opentracing "github.com/opentracing/opentracing-go"
@@ -184,11 +186,14 @@ func MakeFedAPI(
 
 // SetupHTTPAPI registers an HTTP API mux under /api and sets up a metrics
 // listener.
-func SetupHTTPAPI(servMux *http.ServeMux, apiMux http.Handler, cfg *config.Dendrite) {
+func SetupHTTPAPI(servMux *http.ServeMux, publicApiMux *mux.Router, internalApiMux *mux.Router, cfg *config.Dendrite, enableHTTPAPIs bool) {
 	if cfg.Metrics.Enabled {
 		servMux.Handle("/metrics", WrapHandlerInBasicAuth(promhttp.Handler(), cfg.Metrics.BasicAuth))
 	}
-	servMux.Handle("/api/", http.StripPrefix("/api", apiMux))
+	if enableHTTPAPIs {
+		servMux.Handle(httpapis.InternalPathPrefix, internalApiMux)
+	}
+	servMux.Handle(httpapis.PublicPathPrefix, WrapHandlerInCORS(publicApiMux))
 }
 
 // WrapHandlerInBasicAuth adds basic auth to a handler. Only used for /metrics

internal/httpapis/paths.go

@@ -0,0 +1,6 @@
+package httpapis
+
+const (
+	PublicPathPrefix   = "/_matrix/"
+	InternalPathPrefix = "/api/"
+)

internal/keydb/keydb_wasm.go

@@ -43,7 +43,7 @@ func NewDatabase(
 	case "postgres":
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	case "file":
-		return sqlite3.NewDatabase(dataSourceName, serverName, serverKey, serverKeyID)
+		return sqlite3.NewDatabase(uri.Path, serverName, serverKey, serverKeyID)
 	default:
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	}

keyserver/keyserver.go

@@ -28,5 +28,5 @@ func SetupKeyServerComponent(
 	deviceDB devices.Database,
 	accountsDB accounts.Database,
 ) {
-	routing.Setup(base.APIMux, base.Cfg, accountsDB, deviceDB)
+	routing.Setup(base.PublicAPIMux, base.Cfg, accountsDB, deviceDB)
 }

keyserver/routing/routing.go

@@ -27,7 +27,7 @@ import (
 	"github.com/matrix-org/util"
 )
 
-const pathPrefixR0 = "/_matrix/client/r0"
+const pathPrefixR0 = "/client/r0"
 
 // Setup registers HTTP handlers with the given ServeMux. It also supplies the given http.Client
 // to clients which need to make outbound HTTP requests.
@@ -36,11 +36,11 @@ const pathPrefixR0 = "/_matrix/client/r0"
 // applied:
 // nolint: gocyclo
 func Setup(
-	apiMux *mux.Router, cfg *config.Dendrite,
+	publicAPIMux *mux.Router, cfg *config.Dendrite,
 	accountDB accounts.Database,
 	deviceDB devices.Database,
 ) {
-	r0mux := apiMux.PathPrefix(pathPrefixR0).Subrouter()
+	r0mux := publicAPIMux.PathPrefix(pathPrefixR0).Subrouter()
 
 	authData := auth.Data{
 		AccountDB:   accountDB,

mediaapi/mediaapi.go

@@ -35,6 +35,6 @@ func SetupMediaAPIComponent(
 	}
 
 	routing.Setup(
-		base.APIMux, base.Cfg, mediaDB, deviceDB, gomatrixserverlib.NewClient(),
+		base.PublicAPIMux, base.Cfg, mediaDB, deviceDB, gomatrixserverlib.NewClient(),
 	)
 }

mediaapi/routing/routing.go

@@ -33,7 +33,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
-const pathPrefixR0 = "/_matrix/media/r0"
+const pathPrefixR0 = "/media/r0"
 
 // Setup registers the media API HTTP handlers
 //
@@ -41,13 +41,13 @@ const pathPrefixR0 = "/_matrix/media/r0"
 // applied:
 // nolint: gocyclo
 func Setup(
-	apiMux *mux.Router,
+	publicAPIMux *mux.Router,
 	cfg *config.Dendrite,
 	db storage.Database,
 	deviceDB devices.Database,
 	client *gomatrixserverlib.Client,
 ) {
-	r0mux := apiMux.PathPrefix(pathPrefixR0).Subrouter()
+	r0mux := publicAPIMux.PathPrefix(pathPrefixR0).Subrouter()
 
 	activeThumbnailGeneration := &types.ActiveThumbnailGeneration{
 		PathToResult: map[string]*types.ThumbnailGenerationResult{},

mediaapi/storage/storage_wasm.go

@@ -35,7 +35,7 @@ func Open(
 	case "postgres":
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	case "file":
-		return sqlite3.Open(dataSourceName)
+		return sqlite3.Open(uri.Path)
 	default:
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	}

publicroomsapi/publicroomsapi.go

@@ -43,5 +43,5 @@ func SetupPublicRoomsAPIComponent(
 		logrus.WithError(err).Panic("failed to start public rooms server consumer")
 	}
 
-	routing.Setup(base.APIMux, deviceDB, publicRoomsDB, rsAPI, fedClient, extRoomsProvider)
+	routing.Setup(base.PublicAPIMux, deviceDB, publicRoomsDB, rsAPI, fedClient, extRoomsProvider)
 }

publicroomsapi/routing/routing.go

@@ -31,7 +31,7 @@ import (
 	"github.com/matrix-org/util"
 )
 
-const pathPrefixR0 = "/_matrix/client/r0"
+const pathPrefixR0 = "/client/r0"
 
 // Setup configures the given mux with publicroomsapi server listeners
 //
@@ -39,10 +39,10 @@ const pathPrefixR0 = "/_matrix/client/r0"
 // applied:
 // nolint: gocyclo
 func Setup(
-	apiMux *mux.Router, deviceDB devices.Database, publicRoomsDB storage.Database, rsAPI api.RoomserverInternalAPI,
+	publicAPIMux *mux.Router, deviceDB devices.Database, publicRoomsDB storage.Database, rsAPI api.RoomserverInternalAPI,
 	fedClient *gomatrixserverlib.FederationClient, extRoomsProvider types.ExternalPublicRoomsProvider,
 ) {
-	r0mux := apiMux.PathPrefix(pathPrefixR0).Subrouter()
+	r0mux := publicAPIMux.PathPrefix(pathPrefixR0).Subrouter()
 
 	authData := auth.Data{
 		AccountDB:   nil,
@@ -79,7 +79,7 @@ func Setup(
 	).Methods(http.MethodGet, http.MethodPost, http.MethodOptions)
 
 	// Federation - TODO: should this live here or in federation API? It's sure easier if it's here so here it is.
-	apiMux.Handle("/_matrix/federation/v1/publicRooms",
+	publicAPIMux.Handle("/federation/v1/publicRooms",
 		internal.MakeExternalAPI("federation_public_rooms", func(req *http.Request) util.JSONResponse {
 			return directory.GetPostPublicRooms(req, publicRoomsDB)
 		}),

publicroomsapi/storage/storage_wasm.go

@@ -31,7 +31,7 @@ func NewPublicRoomsServerDatabase(dataSourceName string) (Database, error) {
 	case "postgres":
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	case "file":
-		return sqlite3.NewPublicRoomsServerDatabase(dataSourceName)
+		return sqlite3.NewPublicRoomsServerDatabase(uri.Path)
 	default:
 		return nil, fmt.Errorf("Cannot use postgres implementation")
 	}

roomserver/api/alias.go

@@ -85,19 +85,19 @@ type RemoveRoomAliasRequest struct {
 type RemoveRoomAliasResponse struct{}
 
 // RoomserverSetRoomAliasPath is the HTTP path for the SetRoomAlias API.
-const RoomserverSetRoomAliasPath = "/api/roomserver/setRoomAlias"
+const RoomserverSetRoomAliasPath = "/roomserver/setRoomAlias"
 
 // RoomserverGetRoomIDForAliasPath is the HTTP path for the GetRoomIDForAlias API.
-const RoomserverGetRoomIDForAliasPath = "/api/roomserver/GetRoomIDForAlias"
+const RoomserverGetRoomIDForAliasPath = "/roomserver/GetRoomIDForAlias"
 
 // RoomserverGetAliasesForRoomIDPath is the HTTP path for the GetAliasesForRoomID API.
-const RoomserverGetAliasesForRoomIDPath = "/api/roomserver/GetAliasesForRoomID"
+const RoomserverGetAliasesForRoomIDPath = "/roomserver/GetAliasesForRoomID"
 
 // RoomserverGetCreatorIDForAliasPath is the HTTP path for the GetCreatorIDForAlias API.
-const RoomserverGetCreatorIDForAliasPath = "/api/roomserver/GetCreatorIDForAlias"
+const RoomserverGetCreatorIDForAliasPath = "/roomserver/GetCreatorIDForAlias"
 
 // RoomserverRemoveRoomAliasPath is the HTTP path for the RemoveRoomAlias API.
-const RoomserverRemoveRoomAliasPath = "/api/roomserver/removeRoomAlias"
+const RoomserverRemoveRoomAliasPath = "/roomserver/removeRoomAlias"
 
 // SetRoomAlias implements RoomserverAliasAPI
 func (h *httpRoomserverInternalAPI) SetRoomAlias(

roomserver/api/input.go

@@ -103,7 +103,7 @@ type InputRoomEventsResponse struct {
 }
 
 // RoomserverInputRoomEventsPath is the HTTP path for the InputRoomEvents API.
-const RoomserverInputRoomEventsPath = "/api/roomserver/inputRoomEvents"
+const RoomserverInputRoomEventsPath = "/roomserver/inputRoomEvents"
 
 // InputRoomEvents implements RoomserverInputAPI
 func (h *httpRoomserverInternalAPI) InputRoomEvents(

roomserver/api/perform.go

@@ -10,10 +10,10 @@ import (
 
 const (
 	// RoomserverPerformJoinPath is the HTTP path for the PerformJoin API.
-	RoomserverPerformJoinPath = "/api/roomserver/performJoin"
+	RoomserverPerformJoinPath = "/roomserver/performJoin"
 
 	// RoomserverPerformLeavePath is the HTTP path for the PerformLeave API.
-	RoomserverPerformLeavePath = "/api/roomserver/performLeave"
+	RoomserverPerformLeavePath = "/roomserver/performLeave"
 )
 
 type PerformJoinRequest struct {
@@ -24,6 +24,7 @@ type PerformJoinRequest struct {
 }
 
 type PerformJoinResponse struct {
+	RoomID string `json:"room_id"`
 }
 
 func (h *httpRoomserverInternalAPI) PerformJoin(

roomserver/api/query.go

@@ -273,40 +273,40 @@ type QueryRoomVersionForRoomResponse struct {
 }
 
 // RoomserverQueryLatestEventsAndStatePath is the HTTP path for the QueryLatestEventsAndState API.
-const RoomserverQueryLatestEventsAndStatePath = "/api/roomserver/queryLatestEventsAndState"
+const RoomserverQueryLatestEventsAndStatePath = "/roomserver/queryLatestEventsAndState"
 
 // RoomserverQueryStateAfterEventsPath is the HTTP path for the QueryStateAfterEvents API.
-const RoomserverQueryStateAfterEventsPath = "/api/roomserver/queryStateAfterEvents"
+const RoomserverQueryStateAfterEventsPath = "/roomserver/queryStateAfterEvents"
 
 // RoomserverQueryEventsByIDPath is the HTTP path for the QueryEventsByID API.
-const RoomserverQueryEventsByIDPath = "/api/roomserver/queryEventsByID"
+const RoomserverQueryEventsByIDPath = "/roomserver/queryEventsByID"
 
 // RoomserverQueryMembershipForUserPath is the HTTP path for the QueryMembershipForUser API.
-const RoomserverQueryMembershipForUserPath = "/api/roomserver/queryMembershipForUser"
+const RoomserverQueryMembershipForUserPath = "/roomserver/queryMembershipForUser"
 
 // RoomserverQueryMembershipsForRoomPath is the HTTP path for the QueryMembershipsForRoom API
-const RoomserverQueryMembershipsForRoomPath = "/api/roomserver/queryMembershipsForRoom"
+const RoomserverQueryMembershipsForRoomPath = "/roomserver/queryMembershipsForRoom"
 
 // RoomserverQueryInvitesForUserPath is the HTTP path for the QueryInvitesForUser API
-const RoomserverQueryInvitesForUserPath = "/api/roomserver/queryInvitesForUser"
+const RoomserverQueryInvitesForUserPath = "/roomserver/queryInvitesForUser"
 
 // RoomserverQueryServerAllowedToSeeEventPath is the HTTP path for the QueryServerAllowedToSeeEvent API
-const RoomserverQueryServerAllowedToSeeEventPath = "/api/roomserver/queryServerAllowedToSeeEvent"
+const RoomserverQueryServerAllowedToSeeEventPath = "/roomserver/queryServerAllowedToSeeEvent"
 
 // RoomserverQueryMissingEventsPath is the HTTP path for the QueryMissingEvents API
-const RoomserverQueryMissingEventsPath = "/api/roomserver/queryMissingEvents"
+const RoomserverQueryMissingEventsPath = "/roomserver/queryMissingEvents"
 
 // RoomserverQueryStateAndAuthChainPath is the HTTP path for the QueryStateAndAuthChain API
-const RoomserverQueryStateAndAuthChainPath = "/api/roomserver/queryStateAndAuthChain"
+const RoomserverQueryStateAndAuthChainPath = "/roomserver/queryStateAndAuthChain"
 
 // RoomserverQueryBackfillPath is the HTTP path for the QueryBackfillPath API
-const RoomserverQueryBackfillPath = "/api/roomserver/queryBackfill"
+const RoomserverQueryBackfillPath = "/roomserver/queryBackfill"
 
 // RoomserverQueryRoomVersionCapabilitiesPath is the HTTP path for the QueryRoomVersionCapabilities API
-const RoomserverQueryRoomVersionCapabilitiesPath = "/api/roomserver/queryRoomVersionCapabilities"
+const RoomserverQueryRoomVersionCapabilitiesPath = "/roomserver/queryRoomVersionCapabilities"
 
 // RoomserverQueryRoomVersionForRoomPath is the HTTP path for the QueryRoomVersionForRoom API
-const RoomserverQueryRoomVersionForRoomPath = "/api/roomserver/queryRoomVersionForRoom"
+const RoomserverQueryRoomVersionForRoomPath = "/roomserver/queryRoomVersionForRoom"
 
 // QueryLatestEventsAndState implements RoomserverQueryAPI
 func (h *httpRoomserverInternalAPI) QueryLatestEventsAndState(

roomserver/internal/api.go

@@ -6,6 +6,7 @@ import (
 	"sync"
 
 	"github.com/Shopify/sarama"
+	"github.com/gorilla/mux"
 	fsAPI "github.com/matrix-org/dendrite/federationsender/api"
 	"github.com/matrix-org/dendrite/internal"
 	"github.com/matrix-org/dendrite/internal/caching"
@@ -32,8 +33,8 @@ type RoomserverInternalAPI struct {
 
 // SetupHTTP adds the RoomserverInternalAPI handlers to the http.ServeMux.
 // nolint: gocyclo
-func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
+func (r *RoomserverInternalAPI) SetupHTTP(internalAPIMux *mux.Router) {
-	servMux.Handle(api.RoomserverInputRoomEventsPath,
+	internalAPIMux.Handle(api.RoomserverInputRoomEventsPath,
 		internal.MakeInternalAPI("inputRoomEvents", func(req *http.Request) util.JSONResponse {
 			var request api.InputRoomEventsRequest
 			var response api.InputRoomEventsResponse
@@ -46,7 +47,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(api.RoomserverPerformJoinPath,
+	internalAPIMux.Handle(api.RoomserverPerformJoinPath,
 		internal.MakeInternalAPI("performJoin", func(req *http.Request) util.JSONResponse {
 			var request api.PerformJoinRequest
 			var response api.PerformJoinResponse
@@ -59,7 +60,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(api.RoomserverPerformLeavePath,
+	internalAPIMux.Handle(api.RoomserverPerformLeavePath,
 		internal.MakeInternalAPI("performLeave", func(req *http.Request) util.JSONResponse {
 			var request api.PerformLeaveRequest
 			var response api.PerformLeaveResponse
@@ -72,7 +73,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryLatestEventsAndStatePath,
 		internal.MakeInternalAPI("queryLatestEventsAndState", func(req *http.Request) util.JSONResponse {
 			var request api.QueryLatestEventsAndStateRequest
@@ -86,7 +87,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryStateAfterEventsPath,
 		internal.MakeInternalAPI("queryStateAfterEvents", func(req *http.Request) util.JSONResponse {
 			var request api.QueryStateAfterEventsRequest
@@ -100,7 +101,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryEventsByIDPath,
 		internal.MakeInternalAPI("queryEventsByID", func(req *http.Request) util.JSONResponse {
 			var request api.QueryEventsByIDRequest
@@ -114,7 +115,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryMembershipForUserPath,
 		internal.MakeInternalAPI("QueryMembershipForUser", func(req *http.Request) util.JSONResponse {
 			var request api.QueryMembershipForUserRequest
@@ -128,7 +129,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryMembershipsForRoomPath,
 		internal.MakeInternalAPI("queryMembershipsForRoom", func(req *http.Request) util.JSONResponse {
 			var request api.QueryMembershipsForRoomRequest
@@ -142,7 +143,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryInvitesForUserPath,
 		internal.MakeInternalAPI("queryInvitesForUser", func(req *http.Request) util.JSONResponse {
 			var request api.QueryInvitesForUserRequest
@@ -156,7 +157,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryServerAllowedToSeeEventPath,
 		internal.MakeInternalAPI("queryServerAllowedToSeeEvent", func(req *http.Request) util.JSONResponse {
 			var request api.QueryServerAllowedToSeeEventRequest
@@ -170,7 +171,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryMissingEventsPath,
 		internal.MakeInternalAPI("queryMissingEvents", func(req *http.Request) util.JSONResponse {
 			var request api.QueryMissingEventsRequest
@@ -184,7 +185,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryStateAndAuthChainPath,
 		internal.MakeInternalAPI("queryStateAndAuthChain", func(req *http.Request) util.JSONResponse {
 			var request api.QueryStateAndAuthChainRequest
@@ -198,7 +199,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryBackfillPath,
 		internal.MakeInternalAPI("QueryBackfill", func(req *http.Request) util.JSONResponse {
 			var request api.QueryBackfillRequest
@@ -212,7 +213,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryRoomVersionCapabilitiesPath,
 		internal.MakeInternalAPI("QueryRoomVersionCapabilities", func(req *http.Request) util.JSONResponse {
 			var request api.QueryRoomVersionCapabilitiesRequest
@@ -226,7 +227,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverQueryRoomVersionForRoomPath,
 		internal.MakeInternalAPI("QueryRoomVersionForRoom", func(req *http.Request) util.JSONResponse {
 			var request api.QueryRoomVersionForRoomRequest
@@ -240,7 +241,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverSetRoomAliasPath,
 		internal.MakeInternalAPI("setRoomAlias", func(req *http.Request) util.JSONResponse {
 			var request api.SetRoomAliasRequest
@@ -254,7 +255,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverGetRoomIDForAliasPath,
 		internal.MakeInternalAPI("GetRoomIDForAlias", func(req *http.Request) util.JSONResponse {
 			var request api.GetRoomIDForAliasRequest
@@ -268,7 +269,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverGetCreatorIDForAliasPath,
 		internal.MakeInternalAPI("GetCreatorIDForAlias", func(req *http.Request) util.JSONResponse {
 			var request api.GetCreatorIDForAliasRequest
@@ -282,7 +283,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverGetAliasesForRoomIDPath,
 		internal.MakeInternalAPI("getAliasesForRoomID", func(req *http.Request) util.JSONResponse {
 			var request api.GetAliasesForRoomIDRequest
@@ -296,7 +297,7 @@ func (r *RoomserverInternalAPI) SetupHTTP(servMux *http.ServeMux) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	servMux.Handle(
+	internalAPIMux.Handle(
 		api.RoomserverRemoveRoomAliasPath,
 		internal.MakeInternalAPI("removeRoomAlias", func(req *http.Request) util.JSONResponse {
 			var request api.RemoveRoomAliasRequest

roomserver/internal/perform_join.go

@@ -90,6 +90,12 @@ func (r *RoomserverInternalAPI) performJoinRoomByID(
 	req *api.PerformJoinRequest,
 	res *api.PerformJoinResponse, // nolint:unparam
 ) error {
+	// By this point, if req.RoomIDOrAlias contained an alias, then
+	// it will have been overwritten with a room ID by performJoinRoomByAlias.
+	// We should now include this in the response so that the CS API can
+	// return the right room ID.
+	res.RoomID = req.RoomIDOrAlias
+
 	// Get the domain part of the room ID.
 	_, domain, err := gomatrixserverlib.SplitID('!', req.RoomIDOrAlias)
 	if err != nil {
@@ -121,20 +127,30 @@ func (r *RoomserverInternalAPI) performJoinRoomByID(
 		return fmt.Errorf("eb.SetContent: %w", err)
 	}
 
-	// First work out if this is in response to an existing invite.
+	// First work out if this is in response to an existing invite
-	// If it is then we avoid the situation where we might think we
+	// from a federated server. If it is then we avoid the situation
-	// know about a room in the following section but don't know the
+	// where we might think we know about a room in the following
-	// latest state as all of our users have left.
+	// section but don't know the latest state as all of our users
+	// have left.
 	isInvitePending, inviteSender, err := r.isInvitePending(ctx, req.RoomIDOrAlias, req.UserID)
 	if err == nil && isInvitePending {
-		// Add the server of the person who invited us to the server list,
+		// Check if there's an invite pending.
-		// as they should be a fairly good bet.
+		_, inviterDomain, ierr := gomatrixserverlib.SplitID('@', inviteSender)
-		if _, inviterDomain, ierr := gomatrixserverlib.SplitID('@', inviteSender); ierr == nil {
+		if ierr != nil {
-			req.ServerNames = append(req.ServerNames, inviterDomain)
+			return fmt.Errorf("gomatrixserverlib.SplitID: %w", err)
 		}
 
-		// Perform a federated room join.
+		// Check that the domain isn't ours. If it's local then we don't
-		return r.performFederatedJoinRoomByID(ctx, req, res)
+		// need to do anything as our own copy of the room state will be
+		// up-to-date.
+		if inviterDomain != r.Cfg.Matrix.ServerName {
+			// Add the server of the person who invited us to the server list,
+			// as they should be a fairly good bet.
+			req.ServerNames = append(req.ServerNames, inviterDomain)
+
+			// Perform a federated room join.
+			return r.performFederatedJoinRoomByID(ctx, req, res)
+		}
 	}
 
 	// Try to construct an actual join event from the template.

roomserver/roomserver.go

@@ -15,8 +15,6 @@
 package roomserver
 
 import (
-	"net/http"
-
 	"github.com/matrix-org/dendrite/roomserver/api"
 	"github.com/matrix-org/gomatrixserverlib"
 
@@ -51,9 +49,7 @@ func SetupRoomServerComponent(
 		KeyRing:              keyRing,
 	}
 
-	if base.EnableHTTPAPIs {
+	internalAPI.SetupHTTP(base.InternalAPIMux)
-		internalAPI.SetupHTTP(http.DefaultServeMux)
-	}
 
 	return &internalAPI
 }

syncapi/api/query.go

@@ -24,10 +24,10 @@ import (
 )
 
 const (
-	SyncAPIQuerySyncPath      = "/api/syncapi/querySync"
+	SyncAPIQuerySyncPath      = "/syncapi/querySync"
-	SyncAPIQueryStatePath     = "/api/syncapi/queryState"
+	SyncAPIQueryStatePath     = "/syncapi/queryState"
-	SyncAPIQueryStateTypePath = "/api/syncapi/queryStateType"
+	SyncAPIQueryStateTypePath = "/syncapi/queryStateType"
-	SyncAPIQueryMessagesPath  = "/api/syncapi/queryMessages"
+	SyncAPIQueryMessagesPath  = "/syncapi/queryMessages"
 )
 
 func NewSyncQueryAPIHTTP(syncapiURL string, httpClient *http.Client) SyncQueryAPI {

syncapi/routing/routing.go

@@ -30,7 +30,7 @@ import (
 	"github.com/matrix-org/util"
 )
 
-const pathPrefixR0 = "/_matrix/client/r0"
+const pathPrefixR0 = "/client/r0"
 
 // Setup configures the given mux with sync-server listeners
 //
@@ -38,12 +38,12 @@ const pathPrefixR0 = "/_matrix/client/r0"
 // applied:
 // nolint: gocyclo
 func Setup(
-	apiMux *mux.Router, srp *sync.RequestPool, syncDB storage.Database,
+	publicAPIMux *mux.Router, srp *sync.RequestPool, syncDB storage.Database,
 	deviceDB devices.Database, federation *gomatrixserverlib.FederationClient,
 	rsAPI api.RoomserverInternalAPI,
 	cfg *config.Dendrite,
 ) {
-	r0mux := apiMux.PathPrefix(pathPrefixR0).Subrouter()
+	r0mux := publicAPIMux.PathPrefix(pathPrefixR0).Subrouter()
 
 	authData := auth.Data{
 		AccountDB:   nil,

syncapi/syncapi.go

@@ -81,5 +81,5 @@ func SetupSyncAPIComponent(
 		logrus.WithError(err).Panicf("failed to start typing server consumer")
 	}
 
-	routing.Setup(base.APIMux, requestPool, syncDB, deviceDB, federation, rsAPI, cfg)
+	routing.Setup(base.PublicAPIMux, requestPool, syncDB, deviceDB, federation, rsAPI, cfg)
 }

sytest-whitelist

@@ -288,3 +288,4 @@ New room members see their own join event
 Existing members see new members' join events
 Inbound federation can receive events
 Inbound federation can receive redacted events
+Can logout current device