Server key component (#1050)

* Server key API (works for monolith but not for polylith yet)

* Re-enable caching on server key API component

* Groundwork for HTTP APIs for server key API

* Hopefully implement HTTP for server key API

* Simplify public key request marshalling from map keys

* Update gomatrixserverlib

* go mod tidy

* Common -> internal

* remove keyring.go

* Update Docker Hub for server key API

* YAML is funny about indentation

* Wire in new server key API into hybrid monolith mode

* Create maps

* Route server key API endpoints on internal API mux

* Fix server key API URLs

* Add fetcher behaviour into server key API implementation

* Return error if we failed to fetch some keys

* Return results anyway

* Move things about a bit

* Remove unused code

* Fix comments, don't use federation sender URL in polylith mode

* Add server_key_api to sample config

* Review comments

* HTTP API to cache keys that have been requested

* Overwrite server_key_api listen in monolith hybrid mode

serverkeyapi/internal/api.go

@@ -0,0 +1,76 @@
+package internal
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/matrix-org/dendrite/internal/caching"
+	"github.com/matrix-org/dendrite/serverkeyapi/api"
+	"github.com/matrix-org/gomatrixserverlib"
+)
+
+type ServerKeyAPI struct {
+	api.ServerKeyInternalAPI
+
+	ImmutableCache caching.ImmutableCache
+	OurKeyRing     gomatrixserverlib.KeyRing
+	FedClient      *gomatrixserverlib.FederationClient
+}
+
+func (s *ServerKeyAPI) KeyRing() *gomatrixserverlib.KeyRing {
+	// Return a real keyring - one that has the real database and real
+	// fetchers.
+	return &s.OurKeyRing
+}
+
+func (s *ServerKeyAPI) StoreKeys(
+	ctx context.Context,
+	results map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult,
+) error {
+	// Store any keys that we were given in our database.
+	return s.OurKeyRing.KeyDatabase.StoreKeys(ctx, results)
+}
+
+func (s *ServerKeyAPI) FetchKeys(
+	ctx context.Context,
+	requests map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.Timestamp,
+) (map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult, error) {
+	results := map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult{}
+	// First consult our local database and see if we have the requested
+	// keys. These might come from a cache, depending on the database
+	// implementation used.
+	if dbResults, err := s.OurKeyRing.KeyDatabase.FetchKeys(ctx, requests); err == nil {
+		// We successfully got some keys. Add them to the results and
+		// remove them from the request list.
+		for req, res := range dbResults {
+			results[req] = res
+			delete(requests, req)
+		}
+	}
+	// For any key requests that we still have outstanding, next try to
+	// fetch them directly. We'll go through each of the key fetchers to
+	// ask for the remaining keys.
+	for _, fetcher := range s.OurKeyRing.KeyFetchers {
+		if len(requests) == 0 {
+			break
+		}
+		if fetcherResults, err := fetcher.FetchKeys(ctx, requests); err == nil {
+			// We successfully got some keys. Add them to the results and
+			// remove them from the request list.
+			for req, res := range fetcherResults {
+				results[req] = res
+				delete(requests, req)
+			}
+		}
+	}
+	// If we failed to fetch any keys then we should report an error.
+	if len(requests) > 0 {
+		return results, fmt.Errorf("server key API failed to fetch %d keys", len(requests))
+	}
+	// Return the keys.
+	return results, nil
+}
+
+func (s *ServerKeyAPI) FetcherName() string {
+	return s.OurKeyRing.KeyDatabase.FetcherName()
+}

serverkeyapi/internal/http.go

@@ -0,0 +1,60 @@
+package internal
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/gorilla/mux"
+	"github.com/matrix-org/dendrite/internal"
+	"github.com/matrix-org/dendrite/serverkeyapi/api"
+	"github.com/matrix-org/gomatrixserverlib"
+	"github.com/matrix-org/util"
+)
+
+func (s *ServerKeyAPI) SetupHTTP(internalAPIMux *mux.Router) {
+	internalAPIMux.Handle(api.ServerKeyQueryPublicKeyPath,
+		internal.MakeInternalAPI("queryPublicKeys", func(req *http.Request) util.JSONResponse {
+			result := map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult{}
+			request := api.QueryPublicKeysRequest{}
+			response := api.QueryPublicKeysResponse{}
+			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
+				return util.MessageResponse(http.StatusBadRequest, err.Error())
+			}
+			lookup := make(map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.Timestamp)
+			for req, timestamp := range request.Requests {
+				if res, ok := s.ImmutableCache.GetServerKey(req); ok {
+					result[req] = res
+					continue
+				}
+				lookup[req] = timestamp
+			}
+			keys, err := s.FetchKeys(req.Context(), lookup)
+			if err != nil {
+				return util.ErrorResponse(err)
+			}
+			for req, res := range keys {
+				result[req] = res
+			}
+			response.Results = result
+			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
+		}),
+	)
+	internalAPIMux.Handle(api.ServerKeyInputPublicKeyPath,
+		internal.MakeInternalAPI("inputPublicKeys", func(req *http.Request) util.JSONResponse {
+			request := api.InputPublicKeysRequest{}
+			response := api.InputPublicKeysResponse{}
+			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
+				return util.MessageResponse(http.StatusBadRequest, err.Error())
+			}
+			store := make(map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult)
+			for req, res := range request.Keys {
+				store[req] = res
+				s.ImmutableCache.StoreServerKey(req, res)
+			}
+			if err := s.StoreKeys(req.Context(), store); err != nil {
+				return util.ErrorResponse(err)
+			}
+			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
+		}),
+	)
+}