Replace client API config with common config

src/github.com/matrix-org/dendrite/clientapi/config/config.go

@@ -1,37 +0,0 @@
-// Copyright 2017 Vector Creations Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package config
-
-import (
-	"github.com/matrix-org/gomatrixserverlib"
-	"golang.org/x/crypto/ed25519"
-)
-
-// ClientAPI contains the config information necessary to spin up a clientapi process.
-type ClientAPI struct {
-	// The name of the server. This is usually the domain name, e.g 'matrix.org', 'localhost'.
-	ServerName gomatrixserverlib.ServerName
-	// The private key which will be used to sign events.
-	PrivateKey ed25519.PrivateKey
-	// An arbitrary string used to uniquely identify the PrivateKey. Must start with the
-	// prefix "ed25519:".
-	KeyID gomatrixserverlib.KeyID
-	// A list of URIs to send events to. These kafka logs should be consumed by a Room Server.
-	KafkaProducerURIs []string
-	// The topic for events which are written to the logs.
-	ClientAPIOutputTopic string
-	// The URL of the roomserver which can service Query API requests
-	RoomserverURL string
-}

src/github.com/matrix-org/dendrite/clientapi/readers/login.go

@@ -21,9 +21,9 @@ import (
 	"github.com/matrix-org/dendrite/clientapi/auth"
 	"github.com/matrix-org/dendrite/clientapi/auth/storage/accounts"
 	"github.com/matrix-org/dendrite/clientapi/auth/storage/devices"
-	"github.com/matrix-org/dendrite/clientapi/config"
 	"github.com/matrix-org/dendrite/clientapi/httputil"
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
+	"github.com/matrix-org/dendrite/common/config"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/util"
 )
@@ -56,7 +56,10 @@ func passwordLogin() loginFlows {
 }
 
 // Login implements GET and POST /login
-func Login(req *http.Request, accountDB *accounts.Database, deviceDB *devices.Database, cfg config.ClientAPI) util.JSONResponse {
+func Login(
+	req *http.Request, accountDB *accounts.Database, deviceDB *devices.Database,
+	cfg config.Dendrite,
+) util.JSONResponse {
 	if req.Method == "GET" { // TODO: support other forms of login other than password, depending on config options
 		return util.JSONResponse{
 			Code: 200,
@@ -109,7 +112,7 @@ func Login(req *http.Request, accountDB *accounts.Database, deviceDB *devices.Da
 			JSON: loginResponse{
 				UserID:      dev.UserID,
 				AccessToken: dev.AccessToken,
-				HomeServer:  cfg.ServerName,
+				HomeServer:  cfg.Matrix.ServerName,
 			},
 		}
 	}

src/github.com/matrix-org/dendrite/clientapi/routing/routing.go

@@ -22,11 +22,11 @@ import (
 	"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
 	"github.com/matrix-org/dendrite/clientapi/auth/storage/accounts"
 	"github.com/matrix-org/dendrite/clientapi/auth/storage/devices"
-	"github.com/matrix-org/dendrite/clientapi/config"
 	"github.com/matrix-org/dendrite/clientapi/producers"
 	"github.com/matrix-org/dendrite/clientapi/readers"
 	"github.com/matrix-org/dendrite/clientapi/writers"
 	"github.com/matrix-org/dendrite/common"
+	"github.com/matrix-org/dendrite/common/config"
 	"github.com/matrix-org/dendrite/roomserver/api"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/util"
@@ -38,7 +38,7 @@ const pathPrefixR0 = "/_matrix/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.
 func Setup(
-	servMux *http.ServeMux, httpClient *http.Client, cfg config.ClientAPI,
+	servMux *http.ServeMux, httpClient *http.Client, cfg config.Dendrite,
 	producer *producers.RoomserverProducer, queryAPI api.RoomserverQueryAPI,
 	accountDB *accounts.Database,
 	deviceDB *devices.Database,

src/github.com/matrix-org/dendrite/clientapi/writers/createroom.go

@@ -23,11 +23,11 @@ import (
 
 	log "github.com/Sirupsen/logrus"
 	"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
-	"github.com/matrix-org/dendrite/clientapi/config"
 	"github.com/matrix-org/dendrite/clientapi/events"
 	"github.com/matrix-org/dendrite/clientapi/httputil"
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/clientapi/producers"
+	"github.com/matrix-org/dendrite/common/config"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/util"
 )
@@ -91,15 +91,15 @@ type fledglingEvent struct {
 }
 
 // CreateRoom implements /createRoom
-func CreateRoom(req *http.Request, device *authtypes.Device, cfg config.ClientAPI, producer *producers.RoomserverProducer) util.JSONResponse {
+func CreateRoom(req *http.Request, device *authtypes.Device, cfg config.Dendrite, producer *producers.RoomserverProducer) util.JSONResponse {
 	// TODO: Check room ID doesn't clash with an existing one, and we
 	//       probably shouldn't be using pseudo-random strings, maybe GUIDs?
-	roomID := fmt.Sprintf("!%s:%s", util.RandomString(16), cfg.ServerName)
+	roomID := fmt.Sprintf("!%s:%s", util.RandomString(16), cfg.Matrix.ServerName)
 	return createRoom(req, device, cfg, roomID, producer)
 }
 
 // createRoom implements /createRoom
-func createRoom(req *http.Request, device *authtypes.Device, cfg config.ClientAPI, roomID string, producer *producers.RoomserverProducer) util.JSONResponse {
+func createRoom(req *http.Request, device *authtypes.Device, cfg config.Dendrite, roomID string, producer *producers.RoomserverProducer) util.JSONResponse {
 	logger := util.GetLogger(req.Context())
 	userID := device.UserID
 	var r createRoomRequest
@@ -201,7 +201,7 @@ func createRoom(req *http.Request, device *authtypes.Device, cfg config.ClientAP
 // buildEvent fills out auth_events for the builder then builds the event
 func buildEvent(builder *gomatrixserverlib.EventBuilder,
 	provider gomatrixserverlib.AuthEventProvider,
-	cfg config.ClientAPI) (*gomatrixserverlib.Event, error) {
+	cfg config.Dendrite) (*gomatrixserverlib.Event, error) {
 
 	eventsNeeded, err := gomatrixserverlib.StateNeededForEventBuilder(builder)
 	if err != nil {
@@ -212,9 +212,9 @@ func buildEvent(builder *gomatrixserverlib.EventBuilder,
 		return nil, err
 	}
 	builder.AuthEvents = refs
-	eventID := fmt.Sprintf("$%s:%s", util.RandomString(16), cfg.ServerName)
+	eventID := fmt.Sprintf("$%s:%s", util.RandomString(16), cfg.Matrix.ServerName)
 	now := time.Now()
-	event, err := builder.Build(eventID, now, cfg.ServerName, cfg.KeyID, cfg.PrivateKey)
+	event, err := builder.Build(eventID, now, cfg.Matrix.ServerName, cfg.Matrix.KeyID, cfg.Matrix.PrivateKey)
 	if err != nil {
 		return nil, fmt.Errorf("cannot build event %s : Builder failed to build. %s", builder.Type, err)
 	}

src/github.com/matrix-org/dendrite/clientapi/writers/joinroom.go

@@ -17,10 +17,10 @@ package writers
 import (
 	"fmt"
 	"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
-	"github.com/matrix-org/dendrite/clientapi/config"
 	"github.com/matrix-org/dendrite/clientapi/httputil"
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/clientapi/producers"
+	"github.com/matrix-org/dendrite/common/config"
 	"github.com/matrix-org/dendrite/roomserver/api"
 	"github.com/matrix-org/gomatrix"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -36,7 +36,7 @@ func JoinRoomByIDOrAlias(
 	req *http.Request,
 	device *authtypes.Device,
 	roomIDOrAlias string,
-	cfg config.ClientAPI,
+	cfg config.Dendrite,
 	federation *gomatrixserverlib.FederationClient,
 	producer *producers.RoomserverProducer,
 	queryAPI api.RoomserverQueryAPI,
@@ -67,7 +67,7 @@ type joinRoomReq struct {
 	req        *http.Request
 	content    map[string]interface{}
 	userID     string
-	cfg        config.ClientAPI
+	cfg        config.Dendrite
 	federation *gomatrixserverlib.FederationClient
 	producer   *producers.RoomserverProducer
 	queryAPI   api.RoomserverQueryAPI
@@ -95,7 +95,7 @@ func (r joinRoomReq) joinRoomByAlias(roomAlias string) util.JSONResponse {
 			JSON: jsonerror.BadJSON("Room alias must be in the form '#localpart:domain'"),
 		}
 	}
-	if domain == r.cfg.ServerName {
+	if domain == r.cfg.Matrix.ServerName {
 		// TODO: Implement joining local room aliases.
 		panic(fmt.Errorf("Joining local room aliases is not implemented"))
 	} else {
@@ -212,9 +212,9 @@ func (r joinRoomReq) joinRoomUsingServer(roomID string, server gomatrixserverlib
 	r.writeToBuilder(&respMakeJoin.JoinEvent, roomID)
 
 	now := time.Now()
-	eventID := fmt.Sprintf("$%s:%s", util.RandomString(16), r.cfg.ServerName)
+	eventID := fmt.Sprintf("$%s:%s", util.RandomString(16), r.cfg.Matrix.ServerName)
 	event, err := respMakeJoin.JoinEvent.Build(
-		eventID, now, r.cfg.ServerName, r.cfg.KeyID, r.cfg.PrivateKey,
+		eventID, now, r.cfg.Matrix.ServerName, r.cfg.Matrix.KeyID, r.cfg.Matrix.PrivateKey,
 	)
 	if err != nil {
 		res := httputil.LogThenError(r.req, err)

src/github.com/matrix-org/dendrite/clientapi/writers/sendevent.go

@@ -21,10 +21,10 @@ import (
 	"time"
 
 	"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
-	"github.com/matrix-org/dendrite/clientapi/config"
 	"github.com/matrix-org/dendrite/clientapi/httputil"
 	"github.com/matrix-org/dendrite/clientapi/jsonerror"
 	"github.com/matrix-org/dendrite/clientapi/producers"
+	"github.com/matrix-org/dendrite/common/config"
 	"github.com/matrix-org/dendrite/roomserver/api"
 	"github.com/matrix-org/gomatrixserverlib"
 	"github.com/matrix-org/util"
@@ -39,7 +39,14 @@ type sendEventResponse struct {
 // SendEvent implements:
 //   /rooms/{roomID}/send/{eventType}/{txnID}
 //   /rooms/{roomID}/state/{eventType}/{stateKey}
-func SendEvent(req *http.Request, device *authtypes.Device, roomID, eventType, txnID string, stateKey *string, cfg config.ClientAPI, queryAPI api.RoomserverQueryAPI, producer *producers.RoomserverProducer) util.JSONResponse {
+func SendEvent(
+	req *http.Request,
+	device *authtypes.Device,
+	roomID, eventType, txnID string, stateKey *string,
+	cfg config.Dendrite,
+	queryAPI api.RoomserverQueryAPI,
+	producer *producers.RoomserverProducer,
+) util.JSONResponse {
 	// parse the incoming http request
 	userID := device.UserID
 	var r map[string]interface{} // must be a JSON object
@@ -86,8 +93,10 @@ func SendEvent(req *http.Request, device *authtypes.Device, roomID, eventType, t
 		refs = append(refs, e.EventReference())
 	}
 	builder.AuthEvents = refs
-	eventID := fmt.Sprintf("$%s:%s", util.RandomString(16), cfg.ServerName)
-	e, err := builder.Build(eventID, time.Now(), cfg.ServerName, cfg.KeyID, cfg.PrivateKey)
+	eventID := fmt.Sprintf("$%s:%s", util.RandomString(16), cfg.Matrix.ServerName)
+	e, err := builder.Build(
+		eventID, time.Now(), cfg.Matrix.ServerName, cfg.Matrix.KeyID, cfg.Matrix.PrivateKey,
+	)
 	if err != nil {
 		return httputil.LogThenError(req, err)
 	}

src/github.com/matrix-org/dendrite/cmd/dendrite-client-api-server/main.go

@@ -15,16 +15,16 @@
 package main
 
 import (
+	"flag"
 	"net/http"
 	"os"
-	"strings"
 
 	"github.com/matrix-org/dendrite/clientapi/auth/storage/accounts"
 	"github.com/matrix-org/dendrite/clientapi/auth/storage/devices"
-	"github.com/matrix-org/dendrite/clientapi/config"
 	"github.com/matrix-org/dendrite/clientapi/producers"
 	"github.com/matrix-org/dendrite/clientapi/routing"
 	"github.com/matrix-org/dendrite/common"
+	"github.com/matrix-org/dendrite/common/config"
 	"github.com/matrix-org/dendrite/common/keydb"
 	"github.com/matrix-org/dendrite/roomserver/api"
 
@@ -34,70 +34,45 @@ import (
 )
 
 var (
-	kafkaURIs            = strings.Split(os.Getenv("KAFKA_URIS"), ",")
-	bindAddr             = os.Getenv("BIND_ADDRESS")
-	logDir               = os.Getenv("LOG_DIR")
-	roomserverURL        = os.Getenv("ROOMSERVER_URL")
-	clientAPIOutputTopic = os.Getenv("CLIENTAPI_OUTPUT_TOPIC")
-	serverName           = gomatrixserverlib.ServerName(os.Getenv("SERVER_NAME"))
-	serverKey            = os.Getenv("SERVER_KEY")
-	accountDataSource    = os.Getenv("ACCOUNT_DATABASE")
-	keyDataSource        = os.Getenv("KEY_DATABASE")
+	logDir     = os.Getenv("LOG_DIR")
+	configPath = flag.String("config", "dendrite.yaml", "The path to the config file, For more information see the config file in this repository")
 )
 
 func main() {
 	common.SetupLogging(logDir)
-	if bindAddr == "" {
-		log.Panic("No BIND_ADDRESS environment variable found.")
-	}
-	if len(kafkaURIs) == 0 {
-		// the kafka default is :9092
-		kafkaURIs = []string{"localhost:9092"}
-	}
-	if roomserverURL == "" {
-		log.Panic("No ROOMSERVER_URL environment variable found.")
-	}
-	if clientAPIOutputTopic == "" {
-		log.Panic("No CLIENTAPI_OUTPUT_TOPIC environment variable found. This should match the roomserver input topic.")
-	}
-	if serverName == "" {
-		serverName = "localhost"
-	}
 
-	cfg := config.ClientAPI{
-		ServerName:           serverName,
-		KafkaProducerURIs:    kafkaURIs,
-		ClientAPIOutputTopic: clientAPIOutputTopic,
-		RoomserverURL:        roomserverURL,
-	}
+	flag.Parse()
 
-	var err error
-	cfg.KeyID, cfg.PrivateKey, err = common.ReadKey(serverKey)
+	cfg, err := config.Load(*configPath)
 	if err != nil {
-		log.Panicf("Failed to load private key: %s", err)
+		log.Fatalf("Invalid config file: %s", err)
 	}
 
-	log.Info("Starting clientapi")
+	log.Info("config: ", cfg)
 
-	roomserverProducer, err := producers.NewRoomserverProducer(cfg.KafkaProducerURIs, cfg.ClientAPIOutputTopic)
+	roomserverProducer, err := producers.NewRoomserverProducer(
+		cfg.Kafka.Addresses, string(cfg.Kafka.Topics.InputRoomEvent),
+	)
 	if err != nil {
-		log.Panicf("Failed to setup kafka producers(%q): %s", cfg.KafkaProducerURIs, err)
+		log.Panicf("Failed to setup kafka producers(%q): %s", cfg.Kafka.Addresses, err)
 	}
 
-	federation := gomatrixserverlib.NewFederationClient(cfg.ServerName, cfg.KeyID, cfg.PrivateKey)
+	federation := gomatrixserverlib.NewFederationClient(
+		cfg.Matrix.ServerName, cfg.Matrix.KeyID, cfg.Matrix.PrivateKey,
+	)
 
-	queryAPI := api.NewRoomserverQueryAPIHTTP(cfg.RoomserverURL, nil)
-	accountDB, err := accounts.NewDatabase(accountDataSource, serverName)
+	queryAPI := api.NewRoomserverQueryAPIHTTP("http://"+string(cfg.Listen.RoomServer), nil)
+	accountDB, err := accounts.NewDatabase(string(cfg.Database.Account), cfg.Matrix.ServerName)
 	if err != nil {
-		log.Panicf("Failed to setup account database(%q): %s", accountDataSource, err.Error())
+		log.Panicf("Failed to setup account database(%q): %s", cfg.Database.Account, err.Error())
 	}
-	deviceDB, err := devices.NewDatabase(accountDataSource, serverName)
+	deviceDB, err := devices.NewDatabase(string(cfg.Database.Device), cfg.Matrix.ServerName)
 	if err != nil {
-		log.Panicf("Failed to setup device database(%q): %s", accountDataSource, err.Error())
+		log.Panicf("Failed to setup device database(%q): %s", cfg.Database.Device, err.Error())
 	}
-	keyDB, err := keydb.NewDatabase(keyDataSource)
+	keyDB, err := keydb.NewDatabase(string(cfg.Database.ServerKey))
 	if err != nil {
-		log.Panicf("Failed to setup key database(%q): %s", keyDataSource, err.Error())
+		log.Panicf("Failed to setup key database(%q): %s", cfg.Database.ServerKey, err.Error())
 	}
 
 	keyRing := gomatrixserverlib.KeyRing{
@@ -108,9 +83,10 @@ func main() {
 		KeyDatabase: keyDB,
 	}
 
+	log.Info("Starting client API server on ", cfg.Listen.ClientAPI)
 	routing.Setup(
-		http.DefaultServeMux, http.DefaultClient, cfg, roomserverProducer,
+		http.DefaultServeMux, http.DefaultClient, *cfg, roomserverProducer,
 		queryAPI, accountDB, deviceDB, federation, keyRing,
 	)
-	log.Fatal(http.ListenAndServe(bindAddr, nil))
+	log.Fatal(http.ListenAndServe(string(cfg.Listen.ClientAPI), nil))
 }

src/github.com/matrix-org/dendrite/cmd/dendrite-sync-api-server/main.go

@@ -32,7 +32,6 @@ import (
 )
 
 var configPath = flag.String("config", "dendrite.yaml", "The path to the config file. For more information, see the config file in this repository.")
-var bindAddr = flag.String("listen", ":4200", "The port to listen on.")
 
 func main() {
 	common.SetupLogging(os.Getenv("LOG_DIR"))
@@ -47,11 +46,7 @@ func main() {
 		log.Fatalf("Invalid config file: %s", err)
 	}
 
-	if *bindAddr == "" {
-		log.Fatal("--listen must be supplied")
-	}
-
-	log.Info("sync server config: ", cfg)
+	log.Info("config: ", cfg)
 
 	db, err := storage.NewSyncServerDatabase(string(cfg.Database.SyncServer))
 	if err != nil {
@@ -80,7 +75,7 @@ func main() {
 		log.Panicf("startup: failed to start room server consumer")
 	}
 
-	log.Info("Starting sync server on ", *bindAddr)
+	log.Info("Starting sync server on ", cfg.Listen.SyncAPI)
 	routing.SetupSyncServerListeners(http.DefaultServeMux, http.DefaultClient, sync.NewRequestPool(db, n), deviceDB)
-	log.Fatal(http.ListenAndServe(*bindAddr, nil))
+	log.Fatal(http.ListenAndServe(string(cfg.Listen.SyncAPI), nil))
 }