mirrors/dendrite
1
0
Fork 0
mirror of https://github.com/matrix-org/dendrite.git synced 2025-12-25 07:43:10 -06:00
Code Issues Packages Projects Releases Wiki Activity

use jsoniter instead of encoding/json

Browse source
This commit is contained in:
bn4t 2020-10-09 14:28:48 +02:00
parent 1cd525ef0d
commit 1ac0707032
108 changed files with 416 additions and 412 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
appservice/consumers/roomserver.go
View file

@ -16,7 +16,7 @@ package consumers
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"github.com/matrix-org/dendrite/appservice/storage" "github.com/matrix-org/dendrite/appservice/storage"
"github.com/matrix-org/dendrite/appservice/types" "github.com/matrix-org/dendrite/appservice/types"
@ -75,7 +75,7 @@ func (s *OutputRoomEventConsumer) Start() error {
func (s *OutputRoomEventConsumer) onMessage(msg *sarama.ConsumerMessage) error { func (s *OutputRoomEventConsumer) onMessage(msg *sarama.ConsumerMessage) error {
// Parse out the event JSON // Parse out the event JSON
var output api.OutputEvent var output api.OutputEvent
if err := json.Unmarshal(msg.Value, &output); err != nil { if err := jsoniter.Unmarshal(msg.Value, &output); err != nil {
// If the message was invalid, log it and move on to the next message in the stream // If the message was invalid, log it and move on to the next message in the stream
log.WithError(err).Errorf("roomserver output log: message parse failure") log.WithError(err).Errorf("roomserver output log: message parse failure")
return nil return nil

6
appservice/inthttp/server.go
View file

@ -1,7 +1,7 @@
package inthttp package inthttp
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/gorilla/mux" "github.com/gorilla/mux"
@ -17,7 +17,7 @@ func AddRoutes(a api.AppServiceQueryAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("appserviceRoomAliasExists", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("appserviceRoomAliasExists", func(req *http.Request) util.JSONResponse {
var request api.RoomAliasExistsRequest var request api.RoomAliasExistsRequest
var response api.RoomAliasExistsResponse var response api.RoomAliasExistsResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := a.RoomAliasExists(req.Context(), &request, &response); err != nil { if err := a.RoomAliasExists(req.Context(), &request, &response); err != nil {
@ -31,7 +31,7 @@ func AddRoutes(a api.AppServiceQueryAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("appserviceUserIDExists", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("appserviceUserIDExists", func(req *http.Request) util.JSONResponse {
var request api.UserIDExistsRequest var request api.UserIDExistsRequest
var response api.UserIDExistsResponse var response api.UserIDExistsResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := a.UserIDExists(req.Context(), &request, &response); err != nil { if err := a.UserIDExists(req.Context(), &request, &response); err != nil {

6
appservice/storage/postgres/appservice_events_table.go
View file

@ -18,7 +18,7 @@ package postgres
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"time" "time"
"github.com/matrix-org/gomatrixserverlib" "github.com/matrix-org/gomatrixserverlib"
@ -161,7 +161,7 @@ func retrieveEvents(eventRows *sql.Rows, limit int) (events []gomatrixserverlib.
} }
// Unmarshal eventJSON // Unmarshal eventJSON
if err = json.Unmarshal(eventJSON, &event); err != nil { if err = jsoniter.Unmarshal(eventJSON, &event); err != nil {
return nil, 0, 0, false, err return nil, 0, 0, false, err
} }
@ -219,7 +219,7 @@ func (s *eventsStatements) insertEvent(
event *gomatrixserverlib.HeaderedEvent, event *gomatrixserverlib.HeaderedEvent,
) (err error) { ) (err error) {
// Convert event to JSON before inserting // Convert event to JSON before inserting
eventJSON, err := json.Marshal(event) eventJSON, err := jsoniter.Marshal(event)
if err != nil { if err != nil {
return err return err
} }

6
appservice/storage/sqlite3/appservice_events_table.go
View file

@ -18,7 +18,7 @@ package sqlite3
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"time" "time"
"github.com/matrix-org/dendrite/internal/sqlutil" "github.com/matrix-org/dendrite/internal/sqlutil"
@ -166,7 +166,7 @@ func retrieveEvents(eventRows *sql.Rows, limit int) (events []gomatrixserverlib.
} }
// Unmarshal eventJSON // Unmarshal eventJSON
if err = json.Unmarshal(eventJSON, &event); err != nil { if err = jsoniter.Unmarshal(eventJSON, &event); err != nil {
return nil, 0, 0, false, err return nil, 0, 0, false, err
} }
@ -224,7 +224,7 @@ func (s *eventsStatements) insertEvent(
event *gomatrixserverlib.HeaderedEvent, event *gomatrixserverlib.HeaderedEvent,
) (err error) { ) (err error) {
// Convert event to JSON before inserting // Convert event to JSON before inserting
eventJSON, err := json.Marshal(event) eventJSON, err := jsoniter.Marshal(event)
if err != nil { if err != nil {
return err return err
} }

4
appservice/workers/transaction_scheduler.go
View file

@ -17,7 +17,7 @@ package workers
import ( import (
"bytes" "bytes"
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"math" "math"
"net/http" "net/http"
@ -195,7 +195,7 @@ func createTransaction(
Events: ev, Events: ev,
} }
transactionJSON, err = json.Marshal(transaction) transactionJSON, err = jsoniter.Marshal(transaction)
if err != nil { if err != nil {
return return
} }

12
clientapi/auth/user_interactive.go
View file

@ -16,7 +16,7 @@ package auth
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/matrix-org/dendrite/clientapi/jsonerror" "github.com/matrix-org/dendrite/clientapi/jsonerror"
@ -181,19 +181,19 @@ func (u *UserInteractive) NewSession() *util.JSONResponse {
// standard challenge response. // standard challenge response.
func (u *UserInteractive) ResponseWithChallenge(sessionID string, response interface{}) *util.JSONResponse { func (u *UserInteractive) ResponseWithChallenge(sessionID string, response interface{}) *util.JSONResponse {
mixedObjects := make(map[string]interface{}) mixedObjects := make(map[string]interface{})
b, err := json.Marshal(response) b, err := jsoniter.Marshal(response)
if err != nil { if err != nil {
ise := jsonerror.InternalServerError() ise := jsonerror.InternalServerError()
return &ise return &ise
} }
_ = json.Unmarshal(b, &mixedObjects) _ = jsoniter.Unmarshal(b, &mixedObjects)
challenge := u.Challenge(sessionID) challenge := u.Challenge(sessionID)
b, err = json.Marshal(challenge.JSON) b, err = jsoniter.Marshal(challenge.JSON)
if err != nil { if err != nil {
ise := jsonerror.InternalServerError() ise := jsonerror.InternalServerError()
return &ise return &ise
} }
_ = json.Unmarshal(b, &mixedObjects) _ = jsoniter.Unmarshal(b, &mixedObjects)
return &util.JSONResponse{ return &util.JSONResponse{
Code: 401, Code: 401,
@ -237,7 +237,7 @@ func (u *UserInteractive) Verify(ctx context.Context, bodyBytes []byte, device *
} }
r := loginType.Request() r := loginType.Request()
if err := json.Unmarshal([]byte(gjson.GetBytes(bodyBytes, "auth").Raw), r); err != nil { if err := jsoniter.Unmarshal([]byte(gjson.GetBytes(bodyBytes, "auth").Raw), r); err != nil {
return nil, &util.JSONResponse{ return nil, &util.JSONResponse{
Code: http.StatusBadRequest, Code: http.StatusBadRequest,
JSON: jsonerror.BadJSON("The request body could not be decoded into valid JSON. " + err.Error()), JSON: jsonerror.BadJSON("The request body could not be decoded into valid JSON. " + err.Error()),

6
clientapi/auth/user_interactive_test.go
View file

@ -2,7 +2,7 @@ package auth
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"testing" "testing"
@ -62,7 +62,7 @@ func TestUserInteractivePasswordLogin(t *testing.T) {
UserID: fmt.Sprintf("@alice:%s", serverName), UserID: fmt.Sprintf("@alice:%s", serverName),
} }
// valid password requests // valid password requests
testCases := []json.RawMessage{ testCases := []jsoniter.RawMessage{
// deprecated form // deprecated form
[]byte(`{ []byte(`{
"auth": { "auth": {
@ -101,7 +101,7 @@ func TestUserInteractivePasswordBadLogin(t *testing.T) {
} }
// invalid password requests // invalid password requests
testCases := []struct { testCases := []struct {
body json.RawMessage body jsoniter.RawMessage
wantRes util.JSONResponse wantRes util.JSONResponse
}{ }{
{ {

4
clientapi/httputil/httputil.go
View file

@ -15,7 +15,7 @@
package httputil package httputil
import ( import (
"encoding/json" "github.com/json-iterator/go"
"io/ioutil" "io/ioutil"
"net/http" "net/http"
"unicode/utf8" "unicode/utf8"
@ -43,7 +43,7 @@ func UnmarshalJSONRequest(req *http.Request, iface interface{}) *util.JSONRespon
} }
} }
if err := json.Unmarshal(body, iface); err != nil { if err := jsoniter.Unmarshal(body, iface); err != nil {
// TODO: We may want to suppress the Error() return in production? It's useful when // TODO: We may want to suppress the Error() return in production? It's useful when
// debugging because an error will be produced for both invalid/malformed JSON AND // debugging because an error will be produced for both invalid/malformed JSON AND
// valid JSON with incorrect types for values. // valid JSON with incorrect types for values.

6
clientapi/jsonerror/jsonerror_test.go
View file

@ -15,13 +15,13 @@
package jsonerror package jsonerror
import ( import (
"encoding/json" "github.com/json-iterator/go"
"testing" "testing"
) )
func TestLimitExceeded(t *testing.T) { func TestLimitExceeded(t *testing.T) {
e := LimitExceeded("too fast", 5000) e := LimitExceeded("too fast", 5000)
jsonBytes, err := json.Marshal(&e) jsonBytes, err := jsoniter.Marshal(&e)
if err != nil { if err != nil {
t.Fatalf("TestLimitExceeded: Failed to marshal LimitExceeded error. %s", err.Error()) t.Fatalf("TestLimitExceeded: Failed to marshal LimitExceeded error. %s", err.Error())
} }
@ -33,7 +33,7 @@ func TestLimitExceeded(t *testing.T) {
func TestForbidden(t *testing.T) { func TestForbidden(t *testing.T) {
e := Forbidden("you shall not pass") e := Forbidden("you shall not pass")
jsonBytes, err := json.Marshal(&e) jsonBytes, err := jsoniter.Marshal(&e)
if err != nil { if err != nil {
t.Fatalf("TestForbidden: Failed to marshal Forbidden error. %s", err.Error()) t.Fatalf("TestForbidden: Failed to marshal Forbidden error. %s", err.Error())
} }

4
clientapi/producers/syncapi.go
View file

@ -15,7 +15,7 @@
package producers package producers
import ( import (
"encoding/json" "github.com/json-iterator/go"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
"github.com/matrix-org/dendrite/internal/eventutil" "github.com/matrix-org/dendrite/internal/eventutil"
@ -36,7 +36,7 @@ func (p *SyncAPIProducer) SendData(userID string, roomID string, dataType string
RoomID: roomID, RoomID: roomID,
Type: dataType, Type: dataType,
} }
value, err := json.Marshal(data) value, err := jsoniter.Marshal(data)
if err != nil { if err != nil {
return err return err
} }

10
clientapi/routing/account_data.go
View file

@ -15,8 +15,8 @@
package routing package routing
import ( import (
"encoding/json"
"fmt" "fmt"
"github.com/json-iterator/go"
"io/ioutil" "io/ioutil"
"net/http" "net/http"
@ -52,7 +52,7 @@ func GetAccountData(
return util.ErrorResponse(fmt.Errorf("userAPI.QueryAccountData: %w", err)) return util.ErrorResponse(fmt.Errorf("userAPI.QueryAccountData: %w", err))
} }
var data json.RawMessage var data jsoniter.RawMessage
var ok bool var ok bool
if roomID != "" { if roomID != "" {
data, ok = dataRes.RoomAccountData[roomID][dataType] data, ok = dataRes.RoomAccountData[roomID][dataType]
@ -106,7 +106,7 @@ func SaveAccountData(
return jsonerror.InternalServerError() return jsonerror.InternalServerError()
} }
if !json.Valid(body) { if !jsoniter.Valid(body) {
return util.JSONResponse{ return util.JSONResponse{
Code: http.StatusBadRequest, Code: http.StatusBadRequest,
JSON: jsonerror.BadJSON("Bad JSON content"), JSON: jsonerror.BadJSON("Bad JSON content"),
@ -117,7 +117,7 @@ func SaveAccountData(
UserID: userID, UserID: userID,
DataType: dataType, DataType: dataType,
RoomID: roomID, RoomID: roomID,
AccountData: json.RawMessage(body), AccountData: jsoniter.RawMessage(body),
} }
dataRes := api.InputAccountDataResponse{} dataRes := api.InputAccountDataResponse{}
if err := userAPI.InputAccountData(req.Context(), &dataReq, &dataRes); err != nil { if err := userAPI.InputAccountData(req.Context(), &dataReq, &dataRes); err != nil {
@ -170,7 +170,7 @@ func SaveReadMarker(
} }
} }
data, err := json.Marshal(fullyReadEvent{EventID: r.FullyRead}) data, err := jsoniter.Marshal(fullyReadEvent{EventID: r.FullyRead})
if err != nil { if err != nil {
return jsonerror.InternalServerError() return jsonerror.InternalServerError()
} }

6
clientapi/routing/createroom.go
View file

@ -15,7 +15,7 @@
package routing package routing
import ( import (
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"net/http" "net/http"
"strings" "strings"
@ -99,7 +99,7 @@ func (r createRoomRequest) Validate() *util.JSONResponse {
// creation_content map into bytes and then unmarshalling the bytes into // creation_content map into bytes and then unmarshalling the bytes into
// eventutil.CreateContent. // eventutil.CreateContent.
creationContentBytes, err := json.Marshal(r.CreationContent) creationContentBytes, err := jsoniter.Marshal(r.CreationContent)
if err != nil { if err != nil {
return &util.JSONResponse{ return &util.JSONResponse{
Code: http.StatusBadRequest, Code: http.StatusBadRequest,
@ -108,7 +108,7 @@ func (r createRoomRequest) Validate() *util.JSONResponse {
} }
var CreationContent gomatrixserverlib.CreateContent var CreationContent gomatrixserverlib.CreateContent
err = json.Unmarshal(creationContentBytes, &CreationContent) err = jsoniter.Unmarshal(creationContentBytes, &CreationContent)
if err != nil { if err != nil {
return &util.JSONResponse{ return &util.JSONResponse{
Code: http.StatusBadRequest, Code: http.StatusBadRequest,

6
clientapi/routing/keys.go
View file

@ -15,7 +15,7 @@
package routing package routing
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"time" "time"
@ -27,8 +27,8 @@ import (
) )
type uploadKeysRequest struct { type uploadKeysRequest struct {
DeviceKeys json.RawMessage `json:"device_keys"` DeviceKeys jsoniter.RawMessage `json:"device_keys"`
OneTimeKeys map[string]json.RawMessage `json:"one_time_keys"` OneTimeKeys map[string]jsoniter.RawMessage `json:"one_time_keys"`
} }
func UploadKeys(req *http.Request, keyAPI api.KeyInternalAPI, device *userapi.Device) util.JSONResponse { func UploadKeys(req *http.Request, keyAPI api.KeyInternalAPI, device *userapi.Device) util.JSONResponse {

4
clientapi/routing/memberships.go
View file

@ -15,7 +15,7 @@
package routing package routing
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/matrix-org/dendrite/clientapi/jsonerror" "github.com/matrix-org/dendrite/clientapi/jsonerror"
@ -73,7 +73,7 @@ func GetMemberships(
res.Joined = make(map[string]joinedMember) res.Joined = make(map[string]joinedMember)
for _, ev := range queryRes.JoinEvents { for _, ev := range queryRes.JoinEvents {
var content joinedMember var content joinedMember
if err := json.Unmarshal(ev.Content, &content); err != nil { if err := jsoniter.Unmarshal(ev.Content, &content); err != nil {
util.GetLogger(req.Context()).WithError(err).Error("failed to unmarshal event content") util.GetLogger(req.Context()).WithError(err).Error("failed to unmarshal event content")
return jsonerror.InternalServerError() return jsonerror.InternalServerError()
} }

4
clientapi/routing/register.go
View file

@ -19,7 +19,7 @@ import (
"context" "context"
"crypto/hmac" "crypto/hmac"
"crypto/sha1" "crypto/sha1"
"encoding/json" "github.com/json-iterator/go"
"errors" "errors"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
@ -301,7 +301,7 @@ func validateRecaptcha(
JSON: jsonerror.Unknown("Error in contacting captcha server" + err.Error()), JSON: jsonerror.Unknown("Error in contacting captcha server" + err.Error()),
} }
} }
err = json.Unmarshal(body, &r) err = jsoniter.Unmarshal(body, &r)
if err != nil { if err != nil {
return &util.JSONResponse{ return &util.JSONResponse{
Code: http.StatusInternalServerError, Code: http.StatusInternalServerError,

8
clientapi/routing/room_tagging.go
View file

@ -15,7 +15,7 @@
package routing package routing
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/sirupsen/logrus" "github.com/sirupsen/logrus"
@ -183,7 +183,7 @@ func obtainSavedTags(
if !ok { if !ok {
return return
} }
if err = json.Unmarshal(data, &tags); err != nil { if err = jsoniter.Unmarshal(data, &tags); err != nil {
return return
} }
return tags, nil return tags, nil
@ -197,7 +197,7 @@ func saveTagData(
userAPI api.UserInternalAPI, userAPI api.UserInternalAPI,
Tag gomatrix.TagContent, Tag gomatrix.TagContent,
) error { ) error {
newTagData, err := json.Marshal(Tag) newTagData, err := jsoniter.Marshal(Tag)
if err != nil { if err != nil {
return err return err
} }
@ -205,7 +205,7 @@ func saveTagData(
UserID: userID, UserID: userID,
RoomID: roomID, RoomID: roomID,
DataType: "m.tag", DataType: "m.tag",
AccountData: json.RawMessage(newTagData), AccountData: jsoniter.RawMessage(newTagData),
} }
dataRes := api.InputAccountDataResponse{} dataRes := api.InputAccountDataResponse{}
return userAPI.InputAccountData(req.Context(), &dataReq, &dataRes) return userAPI.InputAccountData(req.Context(), &dataReq, &dataRes)

4
clientapi/routing/routing.go
View file

@ -15,7 +15,7 @@
package routing package routing
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"strings" "strings"
@ -466,7 +466,7 @@ func Setup(
r0mux.Handle("/pushrules/", r0mux.Handle("/pushrules/",
httputil.MakeExternalAPI("push_rules", func(req *http.Request) util.JSONResponse { httputil.MakeExternalAPI("push_rules", func(req *http.Request) util.JSONResponse {
// TODO: Implement push rules API // TODO: Implement push rules API
res := json.RawMessage(`{ res := jsoniter.RawMessage(`{
"global": { "global": {
"content": [], "content": [],
"override": [], "override": [],

4
clientapi/routing/sendtodevice.go
View file

@ -13,7 +13,7 @@
package routing package routing
import ( import (
"encoding/json" jsoniter "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/matrix-org/dendrite/clientapi/httputil" "github.com/matrix-org/dendrite/clientapi/httputil"
@ -39,7 +39,7 @@ func SendToDevice(
} }
var httpReq struct { var httpReq struct {
Messages map[string]map[string]json.RawMessage `json:"messages"` Messages map[string]map[string]jsoniter.RawMessage `json:"messages"`
} }
resErr := httputil.UnmarshalJSONRequest(req, &httpReq) resErr := httputil.UnmarshalJSONRequest(req, &httpReq)
if resErr != nil { if resErr != nil {

8
clientapi/routing/state.go
View file

@ -16,7 +16,7 @@ package routing
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"net/http" "net/http"
@ -30,7 +30,7 @@ import (
type stateEventInStateResp struct { type stateEventInStateResp struct {
gomatrixserverlib.ClientEvent gomatrixserverlib.ClientEvent
PrevContent json.RawMessage `json:"prev_content,omitempty"` PrevContent jsoniter.RawMessage `json:"prev_content,omitempty"`
ReplacesState string `json:"replaces_state,omitempty"` ReplacesState string `json:"replaces_state,omitempty"`
} }
@ -63,7 +63,7 @@ func OnIncomingStateRequest(ctx context.Context, device *userapi.Device, rsAPI a
for _, ev := range stateRes.StateEvents { for _, ev := range stateRes.StateEvents {
if ev.Type() == gomatrixserverlib.MRoomHistoryVisibility { if ev.Type() == gomatrixserverlib.MRoomHistoryVisibility {
content := map[string]string{} content := map[string]string{}
if err := json.Unmarshal(ev.Content(), &content); err != nil { if err := jsoniter.Unmarshal(ev.Content(), &content); err != nil {
util.GetLogger(ctx).WithError(err).Error("json.Unmarshal for history visibility failed") util.GetLogger(ctx).WithError(err).Error("json.Unmarshal for history visibility failed")
return jsonerror.InternalServerError() return jsonerror.InternalServerError()
} }
@ -204,7 +204,7 @@ func OnIncomingStateTypeRequest(
for _, ev := range stateRes.StateEvents { for _, ev := range stateRes.StateEvents {
if ev.Type() == gomatrixserverlib.MRoomHistoryVisibility { if ev.Type() == gomatrixserverlib.MRoomHistoryVisibility {
content := map[string]string{} content := map[string]string{}
if err := json.Unmarshal(ev.Content(), &content); err != nil { if err := jsoniter.Unmarshal(ev.Content(), &content); err != nil {
util.GetLogger(ctx).WithError(err).Error("json.Unmarshal for history visibility failed") util.GetLogger(ctx).WithError(err).Error("json.Unmarshal for history visibility failed")
return jsonerror.InternalServerError() return jsonerror.InternalServerError()
} }

10
clientapi/threepid/invites.go
View file

@ -16,7 +16,7 @@ package threepid
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"errors" "errors"
"fmt" "fmt"
"net/http" "net/http"
@ -197,7 +197,7 @@ func queryIDServerLookup(ctx context.Context, body *MembershipRequest) (*idServe
} }
var res idServerLookupResponse var res idServerLookupResponse
err = json.NewDecoder(resp.Body).Decode(&res) err = jsoniter.NewDecoder(resp.Body).Decode(&res)
return &res, err return &res, err
} }
@ -258,7 +258,7 @@ func queryIDServerStoreInvite(
} }
var idResp idServerStoreInviteResponse var idResp idServerStoreInviteResponse
err = json.NewDecoder(resp.Body).Decode(&idResp) err = jsoniter.NewDecoder(resp.Body).Decode(&idResp)
return &idResp, err return &idResp, err
} }
@ -287,7 +287,7 @@ func queryIDServerPubKey(ctx context.Context, idServerName string, keyID string)
return nil, errors.New(errMsg) return nil, errors.New(errMsg)
} }
err = json.NewDecoder(resp.Body).Decode(&pubKeyRes) err = jsoniter.NewDecoder(resp.Body).Decode(&pubKeyRes)
return pubKeyRes.PublicKey, err return pubKeyRes.PublicKey, err
} }
@ -302,7 +302,7 @@ func checkIDServerSignatures(
ctx context.Context, body *MembershipRequest, res *idServerLookupResponse, ctx context.Context, body *MembershipRequest, res *idServerLookupResponse,
) error { ) error {
// Mashall the body so we can give it to VerifyJSON // Mashall the body so we can give it to VerifyJSON
marshalledBody, err := json.Marshal(*res) marshalledBody, err := jsoniter.Marshal(*res)
if err != nil { if err != nil {
return err return err
} }

6
clientapi/threepid/threepid.go
View file

@ -16,7 +16,7 @@ package threepid
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"errors" "errors"
"fmt" "fmt"
"net/http" "net/http"
@ -88,7 +88,7 @@ func CreateSession(
var sid struct { var sid struct {
SID string `json:"sid"` SID string `json:"sid"`
} }
err = json.NewDecoder(resp.Body).Decode(&sid) err = jsoniter.NewDecoder(resp.Body).Decode(&sid)
return sid.SID, err return sid.SID, err
} }
@ -125,7 +125,7 @@ func CheckAssociation(
Error string `json:"error"` Error string `json:"error"`
} }
if err = json.NewDecoder(resp.Body).Decode(&respBody); err != nil { if err = jsoniter.NewDecoder(resp.Body).Decode(&respBody); err != nil {
return false, "", "", err return false, "", "", err
} }

4
cmd/create-room-events/main.go
View file

@ -18,7 +18,7 @@ package main
import ( import (
"encoding/base64" "encoding/base64"
"encoding/json" "github.com/json-iterator/go"
"flag" "flag"
"fmt" "fmt"
"os" "os"
@ -124,7 +124,7 @@ func buildAndOutput() gomatrixserverlib.EventReference {
// Write an event to the output. // Write an event to the output.
func writeEvent(event gomatrixserverlib.Event) { func writeEvent(event gomatrixserverlib.Event) {
encoder := json.NewEncoder(os.Stdout) encoder := jsoniter.NewEncoder(os.Stdout)
if *format == "InputRoomEvent" { if *format == "InputRoomEvent" {
var ire api.InputRoomEvent var ire api.InputRoomEvent
ire.Kind = api.KindNew ire.Kind = api.KindNew

6
cmd/dendrite-demo-libp2p/publicrooms.go
View file

@ -16,7 +16,7 @@ package main
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"sync" "sync"
"sync/atomic" "sync/atomic"
@ -110,7 +110,7 @@ func (p *publicRoomsProvider) AdvertiseRooms() error {
} }
advertised := 0 advertised := 0
for _, room := range ourRooms { for _, room := range ourRooms {
if j, err := json.Marshal(room); err == nil { if j, err := jsoniter.Marshal(room); err == nil {
if err := p.topic.Publish(context.TODO(), j); err != nil { if err := p.topic.Publish(context.TODO(), j); err != nil {
fmt.Println("Failed to publish public room:", err) fmt.Println("Failed to publish public room:", err)
} else { } else {
@ -132,7 +132,7 @@ func (p *publicRoomsProvider) FindRooms() {
received := discoveredRoom{ received := discoveredRoom{
time: time.Now(), time: time.Now(),
} }
if err := json.Unmarshal(msg.Data, &received.room); err != nil { if err := jsoniter.Unmarshal(msg.Data, &received.room); err != nil {
fmt.Println("Unmarshal error:", err) fmt.Println("Unmarshal error:", err)
continue continue
} }

6
cmd/dendrite-demo-yggdrasil/yggconn/node.go
View file

@ -19,7 +19,7 @@ import (
"crypto/ed25519" "crypto/ed25519"
"crypto/tls" "crypto/tls"
"encoding/hex" "encoding/hex"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"log" "log"
@ -89,7 +89,7 @@ func Setup(instanceName, storageDirectory string) (*Node, error) {
if e != nil { if e != nil {
panic(err) panic(err)
} }
if err := json.Unmarshal([]byte(yggconf), &n.config); err != nil { if err := jsoniter.Unmarshal([]byte(yggconf), &n.config); err != nil {
panic(err) panic(err)
} }
} }
@ -113,7 +113,7 @@ func Setup(instanceName, storageDirectory string) (*Node, error) {
n.config.EncryptionPrivateKey = hex.EncodeToString(n.EncryptionPrivateKey()) n.config.EncryptionPrivateKey = hex.EncodeToString(n.EncryptionPrivateKey())
n.config.EncryptionPublicKey = hex.EncodeToString(n.EncryptionPublicKey()) n.config.EncryptionPublicKey = hex.EncodeToString(n.EncryptionPublicKey())
j, err := json.MarshalIndent(n.config, "", " ") j, err := jsoniter.MarshalIndent(n.config, "", " ")
if err != nil { if err != nil {
panic(err) panic(err)
} }

6
cmd/furl/main.go
View file

@ -5,7 +5,7 @@ import (
"bytes" "bytes"
"context" "context"
"crypto/ed25519" "crypto/ed25519"
"encoding/json" "github.com/json-iterator/go"
"encoding/pem" "encoding/pem"
"flag" "flag"
"fmt" "fmt"
@ -75,7 +75,7 @@ func main() {
bodyBytes = append(bodyBytes, bytes...) bodyBytes = append(bodyBytes, bytes...)
} }
fmt.Println("Done!") fmt.Println("Done!")
if err = json.Unmarshal(bodyBytes, &bodyObj); err != nil { if err = jsoniter.Unmarshal(bodyBytes, &bodyObj); err != nil {
panic(err) panic(err)
} }
} }
@ -115,7 +115,7 @@ func main() {
panic(err) panic(err)
} }
j, err := json.MarshalIndent(res, "", " ") j, err := jsoniter.MarshalIndent(res, "", " ")
if err != nil { if err != nil {
panic(err) panic(err)
} }

4
cmd/roomserver-integration-tests/main.go
View file

@ -24,7 +24,7 @@ import (
"strings" "strings"
"time" "time"
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
@ -207,7 +207,7 @@ func writeToRoomServer(input []string, roomserverURL string) error {
var err error var err error
request.InputRoomEvents = make([]api.InputRoomEvent, len(input)) request.InputRoomEvents = make([]api.InputRoomEvent, len(input))
for i := range input { for i := range input {
if err = json.Unmarshal([]byte(input[i]), &request.InputRoomEvents[i]); err != nil { if err = jsoniter.Unmarshal([]byte(input[i]), &request.InputRoomEvents[i]); err != nil {
return err return err
} }
} }

6
cmd/syncserver-integration-tests/main.go
View file

@ -15,7 +15,7 @@
package main package main
import ( import (
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"net/http" "net/http"
@ -100,13 +100,13 @@ func createTestUser(database, username, token string) error {
// Panics if there are any problems. // Panics if there are any problems.
func clientEventJSONForOutputRoomEvent(outputRoomEvent string) string { func clientEventJSONForOutputRoomEvent(outputRoomEvent string) string {
var out api.OutputEvent var out api.OutputEvent
if err := json.Unmarshal([]byte(outputRoomEvent), &out); err != nil { if err := jsoniter.Unmarshal([]byte(outputRoomEvent), &out); err != nil {
panic("failed to unmarshal output room event: " + err.Error()) panic("failed to unmarshal output room event: " + err.Error())
} }
clientEvs := gomatrixserverlib.ToClientEvents([]gomatrixserverlib.Event{ clientEvs := gomatrixserverlib.ToClientEvents([]gomatrixserverlib.Event{
out.NewRoomEvent.Event.Event, out.NewRoomEvent.Event.Event,
}, gomatrixserverlib.FormatSync) }, gomatrixserverlib.FormatSync)
b, err := json.Marshal(clientEvs[0]) b, err := jsoniter.Marshal(clientEvs[0])
if err != nil { if err != nil {
panic("failed to marshal client event as json: " + err.Error()) panic("failed to marshal client event as json: " + err.Error())
} }

4
eduserver/api/wrapper.go
View file

@ -16,7 +16,7 @@ package api
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"time" "time"
"github.com/matrix-org/gomatrixserverlib" "github.com/matrix-org/gomatrixserverlib"
@ -48,7 +48,7 @@ func SendToDevice(
ctx context.Context, eduAPI EDUServerInputAPI, sender, userID, deviceID, eventType string, ctx context.Context, eduAPI EDUServerInputAPI, sender, userID, deviceID, eventType string,
message interface{}, message interface{},
) error { ) error {
js, err := json.Marshal(message) js, err := jsoniter.Marshal(message)
if err != nil { if err != nil {
return err return err
} }

8
eduserver/input/input.go
View file

@ -18,7 +18,7 @@ package input
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"time" "time"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
@ -93,7 +93,7 @@ func (t *EDUServerInputAPI) sendTypingEvent(ite *api.InputTypingEvent) error {
ote.ExpireTime = &expireTime ote.ExpireTime = &expireTime
} }
eventJSON, err := json.Marshal(ote) eventJSON, err := jsoniter.Marshal(ote)
if err != nil { if err != nil {
return err return err
} }
@ -152,9 +152,9 @@ func (t *EDUServerInputAPI) sendToDeviceEvent(ise *api.InputSendToDeviceEvent) e
SendToDeviceEvent: ise.SendToDeviceEvent, SendToDeviceEvent: ise.SendToDeviceEvent,
} }
eventJSON, err := json.Marshal(ote) eventJSON, err := jsoniter.Marshal(ote)
if err != nil { if err != nil {
logrus.WithError(err).Error("sendToDevice failed json.Marshal") logrus.WithError(err).Error("sendToDevice failed jsoniter.Marshal")
return err return err
} }

6
eduserver/inthttp/server.go
View file

@ -1,7 +1,7 @@
package inthttp package inthttp
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/gorilla/mux" "github.com/gorilla/mux"
@ -16,7 +16,7 @@ func AddRoutes(t api.EDUServerInputAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("inputTypingEvents", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("inputTypingEvents", func(req *http.Request) util.JSONResponse {
var request api.InputTypingEventRequest var request api.InputTypingEventRequest
var response api.InputTypingEventResponse var response api.InputTypingEventResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := t.InputTypingEvent(req.Context(), &request, &response); err != nil { if err := t.InputTypingEvent(req.Context(), &request, &response); err != nil {
@ -29,7 +29,7 @@ func AddRoutes(t api.EDUServerInputAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("inputSendToDeviceEvents", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("inputSendToDeviceEvents", func(req *http.Request) util.JSONResponse {
var request api.InputSendToDeviceEventRequest var request api.InputSendToDeviceEventRequest
var response api.InputSendToDeviceEventResponse var response api.InputSendToDeviceEventResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := t.InputSendToDeviceEvent(req.Context(), &request, &response); err != nil { if err := t.InputSendToDeviceEvent(req.Context(), &request, &response); err != nil {

2
federationapi/routing/backfill.go
View file

@ -102,7 +102,7 @@ func Backfill(
} }
} }
eventJSONs := []json.RawMessage{} var eventJSONs []json.RawMessage
for _, e := range gomatrixserverlib.ReverseTopologicalOrdering( for _, e := range gomatrixserverlib.ReverseTopologicalOrdering(
evs, evs,
gomatrixserverlib.TopologicalOrderByPrevEvents, gomatrixserverlib.TopologicalOrderByPrevEvents,

4
federationapi/routing/devices.go
View file

@ -13,7 +13,7 @@
package routing package routing
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/matrix-org/dendrite/clientapi/jsonerror" "github.com/matrix-org/dendrite/clientapi/jsonerror"
@ -45,7 +45,7 @@ func GetUserDevices(
for _, dev := range res.Devices { for _, dev := range res.Devices {
var key gomatrixserverlib.RespUserDeviceKeys var key gomatrixserverlib.RespUserDeviceKeys
err := json.Unmarshal(dev.DeviceKeys.KeyJSON, &key) err := jsoniter.Unmarshal(dev.DeviceKeys.KeyJSON, &key)
if err != nil { if err != nil {
util.GetLogger(req.Context()).WithError(err).Warnf("malformed device key: %s", string(dev.DeviceKeys.KeyJSON)) util.GetLogger(req.Context()).WithError(err).Warnf("malformed device key: %s", string(dev.DeviceKeys.KeyJSON))
continue continue

6
federationapi/routing/invite.go
View file

@ -16,7 +16,7 @@ package routing
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"net/http" "net/http"
@ -39,7 +39,7 @@ func InviteV2(
keys gomatrixserverlib.JSONVerifier, keys gomatrixserverlib.JSONVerifier,
) util.JSONResponse { ) util.JSONResponse {
inviteReq := gomatrixserverlib.InviteV2Request{} inviteReq := gomatrixserverlib.InviteV2Request{}
err := json.Unmarshal(request.Content(), &inviteReq) err := jsoniter.Unmarshal(request.Content(), &inviteReq)
switch err.(type) { switch err.(type) {
case gomatrixserverlib.BadJSONError: case gomatrixserverlib.BadJSONError:
return util.JSONResponse{ return util.JSONResponse{
@ -85,7 +85,7 @@ func InviteV1(
} }
} }
var strippedState []gomatrixserverlib.InviteV2StrippedState var strippedState []gomatrixserverlib.InviteV2StrippedState
if err := json.Unmarshal(event.Unsigned(), &strippedState); err != nil { if err := jsoniter.Unmarshal(event.Unsigned(), &strippedState); err != nil {
// just warn, they may not have added any. // just warn, they may not have added any.
util.GetLogger(httpReq.Context()).Warnf("failed to extract stripped state from invite event") util.GetLogger(httpReq.Context()).Warnf("failed to extract stripped state from invite event")
} }

14
federationapi/routing/keys.go
View file

@ -15,7 +15,7 @@
package routing package routing
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"time" "time"
@ -40,7 +40,7 @@ func QueryDeviceKeys(
httpReq *http.Request, request *gomatrixserverlib.FederationRequest, keyAPI api.KeyInternalAPI, thisServer gomatrixserverlib.ServerName, httpReq *http.Request, request *gomatrixserverlib.FederationRequest, keyAPI api.KeyInternalAPI, thisServer gomatrixserverlib.ServerName,
) util.JSONResponse { ) util.JSONResponse {
var qkr queryKeysRequest var qkr queryKeysRequest
err := json.Unmarshal(request.Content(), &qkr) err := jsoniter.Unmarshal(request.Content(), &qkr)
if err != nil { if err != nil {
return util.JSONResponse{ return util.JSONResponse{
Code: http.StatusBadRequest, Code: http.StatusBadRequest,
@ -86,7 +86,7 @@ func ClaimOneTimeKeys(
httpReq *http.Request, request *gomatrixserverlib.FederationRequest, keyAPI api.KeyInternalAPI, thisServer gomatrixserverlib.ServerName, httpReq *http.Request, request *gomatrixserverlib.FederationRequest, keyAPI api.KeyInternalAPI, thisServer gomatrixserverlib.ServerName,
) util.JSONResponse { ) util.JSONResponse {
var cor claimOTKsRequest var cor claimOTKsRequest
err := json.Unmarshal(request.Content(), &cor) err := jsoniter.Unmarshal(request.Content(), &cor)
if err != nil { if err != nil {
return util.JSONResponse{ return util.JSONResponse{
Code: http.StatusBadRequest, Code: http.StatusBadRequest,
@ -156,7 +156,7 @@ func localKeys(cfg *config.FederationAPI, validUntil time.Time) (*gomatrixserver
} }
} }
toSign, err := json.Marshal(keys.ServerKeyFields) toSign, err := jsoniter.Marshal(keys.ServerKeyFields)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -184,9 +184,9 @@ func NotaryKeys(
} }
var response struct { var response struct {
ServerKeys []json.RawMessage `json:"server_keys"` ServerKeys []jsoniter.RawMessage `json:"server_keys"`
} }
response.ServerKeys = []json.RawMessage{} response.ServerKeys = []jsoniter.RawMessage{}
for serverName := range req.ServerKeys { for serverName := range req.ServerKeys {
var keys *gomatrixserverlib.ServerKeys var keys *gomatrixserverlib.ServerKeys
@ -207,7 +207,7 @@ func NotaryKeys(
continue continue
} }
j, err := json.Marshal(keys) j, err := jsoniter.Marshal(keys)
if err != nil { if err != nil {
logrus.WithError(err).Errorf("Failed to marshal %q response", serverName) logrus.WithError(err).Errorf("Failed to marshal %q response", serverName)
return jsonerror.InternalServerError() return jsonerror.InternalServerError()

4
federationapi/routing/missingevents.go
View file

@ -13,7 +13,7 @@
package routing package routing
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/matrix-org/dendrite/clientapi/jsonerror" "github.com/matrix-org/dendrite/clientapi/jsonerror"
@ -38,7 +38,7 @@ func GetMissingEvents(
roomID string, roomID string,
) util.JSONResponse { ) util.JSONResponse {
var gme getMissingEventRequest var gme getMissingEventRequest
if err := json.Unmarshal(request.Content(), &gme); err != nil { if err := jsoniter.Unmarshal(request.Content(), &gme); err != nil {
return util.JSONResponse{ return util.JSONResponse{
Code: http.StatusBadRequest, Code: http.StatusBadRequest,
JSON: jsonerror.NotJSON("The request body could not be decoded into valid JSON. " + err.Error()), JSON: jsonerror.NotJSON("The request body could not be decoded into valid JSON. " + err.Error()),

11
federationapi/routing/send.go
View file

@ -17,6 +17,7 @@ package routing
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"github.com/json-iterator/go"
"fmt" "fmt"
"net/http" "net/http"
"sync" "sync"
@ -59,7 +60,7 @@ func Send(
EDUs []gomatrixserverlib.EDU `json:"edus"` EDUs []gomatrixserverlib.EDU `json:"edus"`
} }
if err := json.Unmarshal(request.Content(), &txnEvents); err != nil { if err := jsoniter.Unmarshal(request.Content(), &txnEvents); err != nil {
return util.JSONResponse{ return util.JSONResponse{
Code: http.StatusBadRequest, Code: http.StatusBadRequest,
JSON: jsonerror.NotJSON("The request body could not be decoded into valid JSON. " + err.Error()), JSON: jsonerror.NotJSON("The request body could not be decoded into valid JSON. " + err.Error()),
@ -132,7 +133,7 @@ func (t *txnReq) processTransaction(ctx context.Context) (*gomatrixserverlib.Res
var header struct { var header struct {
RoomID string `json:"room_id"` RoomID string `json:"room_id"`
} }
if err := json.Unmarshal(pdu, &header); err != nil { if err := jsoniter.Unmarshal(pdu, &header); err != nil {
util.GetLogger(ctx).WithError(err).Warn("Transaction: Failed to extract room ID from event") util.GetLogger(ctx).WithError(err).Warn("Transaction: Failed to extract room ID from event")
// We don't know the event ID at this point so we can't return the // We don't know the event ID at this point so we can't return the
// failure in the PDU results // failure in the PDU results
@ -295,7 +296,7 @@ func (t *txnReq) processEDUs(ctx context.Context) {
UserID string `json:"user_id"` UserID string `json:"user_id"`
Typing bool `json:"typing"` Typing bool `json:"typing"`
} }
if err := json.Unmarshal(e.Content, &typingPayload); err != nil { if err := jsoniter.Unmarshal(e.Content, &typingPayload); err != nil {
util.GetLogger(ctx).WithError(err).Error("Failed to unmarshal typing event") util.GetLogger(ctx).WithError(err).Error("Failed to unmarshal typing event")
continue continue
} }
@ -305,7 +306,7 @@ func (t *txnReq) processEDUs(ctx context.Context) {
case gomatrixserverlib.MDirectToDevice: case gomatrixserverlib.MDirectToDevice:
// https://matrix.org/docs/spec/server_server/r0.1.3#m-direct-to-device-schema // https://matrix.org/docs/spec/server_server/r0.1.3#m-direct-to-device-schema
var directPayload gomatrixserverlib.ToDeviceMessage var directPayload gomatrixserverlib.ToDeviceMessage
if err := json.Unmarshal(e.Content, &directPayload); err != nil { if err := jsoniter.Unmarshal(e.Content, &directPayload); err != nil {
util.GetLogger(ctx).WithError(err).Error("Failed to unmarshal send-to-device events") util.GetLogger(ctx).WithError(err).Error("Failed to unmarshal send-to-device events")
continue continue
} }
@ -331,7 +332,7 @@ func (t *txnReq) processEDUs(ctx context.Context) {
func (t *txnReq) processDeviceListUpdate(ctx context.Context, e gomatrixserverlib.EDU) { func (t *txnReq) processDeviceListUpdate(ctx context.Context, e gomatrixserverlib.EDU) {
var payload gomatrixserverlib.DeviceListUpdateEvent var payload gomatrixserverlib.DeviceListUpdateEvent
if err := json.Unmarshal(e.Content, &payload); err != nil { if err := jsoniter.Unmarshal(e.Content, &payload); err != nil {
util.GetLogger(ctx).WithError(err).Error("Failed to unmarshal device list update event") util.GetLogger(ctx).WithError(err).Error("Failed to unmarshal device list update event")
return return
} }

2
federationapi/routing/send_test.go
View file

@ -2,7 +2,7 @@ package routing
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"reflect" "reflect"
"testing" "testing"

8
federationapi/routing/threepid.go
View file

@ -16,7 +16,7 @@ package routing
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"errors" "errors"
"net/http" "net/http"
"time" "time"
@ -110,7 +110,7 @@ func ExchangeThirdPartyInvite(
federation *gomatrixserverlib.FederationClient, federation *gomatrixserverlib.FederationClient,
) util.JSONResponse { ) util.JSONResponse {
var builder gomatrixserverlib.EventBuilder var builder gomatrixserverlib.EventBuilder
if err := json.Unmarshal(request.Content(), &builder); err != nil { if err := jsoniter.Unmarshal(request.Content(), &builder); err != nil {
return util.JSONResponse{ return util.JSONResponse{
Code: http.StatusBadRequest, Code: http.StatusBadRequest,
JSON: jsonerror.NotJSON("The request body could not be decoded into valid JSON. " + err.Error()), JSON: jsonerror.NotJSON("The request body could not be decoded into valid JSON. " + err.Error()),
@ -367,7 +367,7 @@ func fillDisplayName(
builder *gomatrixserverlib.EventBuilder, authEvents gomatrixserverlib.AuthEvents, builder *gomatrixserverlib.EventBuilder, authEvents gomatrixserverlib.AuthEvents,
) error { ) error {
var content gomatrixserverlib.MemberContent var content gomatrixserverlib.MemberContent
if err := json.Unmarshal(builder.Content, &content); err != nil { if err := jsoniter.Unmarshal(builder.Content, &content); err != nil {
return err return err
} }
@ -380,7 +380,7 @@ func fillDisplayName(
} }
var thirdPartyInviteContent gomatrixserverlib.ThirdPartyInviteContent var thirdPartyInviteContent gomatrixserverlib.ThirdPartyInviteContent
if err := json.Unmarshal(thirdPartyInviteEvent.Content(), &thirdPartyInviteContent); err != nil { if err := jsoniter.Unmarshal(thirdPartyInviteEvent.Content(), &thirdPartyInviteContent); err != nil {
return err return err
} }

9
federationsender/consumers/eduserver.go
View file

@ -17,6 +17,7 @@ package consumers
import ( import (
"context" "context"
"encoding/json" "encoding/json"
"github.com/json-iterator/go"
"fmt" "fmt"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
@ -89,7 +90,7 @@ func (t *OutputEDUConsumer) Start() error {
func (t *OutputEDUConsumer) onSendToDeviceEvent(msg *sarama.ConsumerMessage) error { func (t *OutputEDUConsumer) onSendToDeviceEvent(msg *sarama.ConsumerMessage) error {
// Extract the send-to-device event from msg. // Extract the send-to-device event from msg.
var ote api.OutputSendToDeviceEvent var ote api.OutputSendToDeviceEvent
if err := json.Unmarshal(msg.Value, &ote); err != nil { if err := jsoniter.Unmarshal(msg.Value, &ote); err != nil {
log.WithError(err).Errorf("eduserver output log: message parse failed (expected send-to-device)") log.WithError(err).Errorf("eduserver output log: message parse failed (expected send-to-device)")
return nil return nil
} }
@ -126,7 +127,7 @@ func (t *OutputEDUConsumer) onSendToDeviceEvent(msg *sarama.ConsumerMessage) err
}, },
}, },
} }
if edu.Content, err = json.Marshal(tdm); err != nil { if edu.Content, err = jsoniter.Marshal(tdm); err != nil {
return err return err
} }
@ -139,7 +140,7 @@ func (t *OutputEDUConsumer) onSendToDeviceEvent(msg *sarama.ConsumerMessage) err
func (t *OutputEDUConsumer) onTypingEvent(msg *sarama.ConsumerMessage) error { func (t *OutputEDUConsumer) onTypingEvent(msg *sarama.ConsumerMessage) error {
// Extract the typing event from msg. // Extract the typing event from msg.
var ote api.OutputTypingEvent var ote api.OutputTypingEvent
if err := json.Unmarshal(msg.Value, &ote); err != nil { if err := jsoniter.Unmarshal(msg.Value, &ote); err != nil {
// Skip this msg but continue processing messages. // Skip this msg but continue processing messages.
log.WithError(err).Errorf("eduserver output log: message parse failed (expected typing)") log.WithError(err).Errorf("eduserver output log: message parse failed (expected typing)")
return nil return nil
@ -167,7 +168,7 @@ func (t *OutputEDUConsumer) onTypingEvent(msg *sarama.ConsumerMessage) error {
} }
edu := &gomatrixserverlib.EDU{Type: ote.Event.Type} edu := &gomatrixserverlib.EDU{Type: ote.Event.Type}
if edu.Content, err = json.Marshal(map[string]interface{}{ if edu.Content, err = jsoniter.Marshal(map[string]interface{}{
"room_id": ote.Event.RoomID, "room_id": ote.Event.RoomID,
"user_id": ote.Event.UserID, "user_id": ote.Event.UserID,
"typing": ote.Event.Typing, "typing": ote.Event.Typing,

6
federationsender/consumers/keychange.go
View file

@ -16,7 +16,7 @@ package consumers
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
@ -76,7 +76,7 @@ func (t *KeyChangeConsumer) Start() error {
// key change events topic from the key server. // key change events topic from the key server.
func (t *KeyChangeConsumer) onMessage(msg *sarama.ConsumerMessage) error { func (t *KeyChangeConsumer) onMessage(msg *sarama.ConsumerMessage) error {
var m api.DeviceMessage var m api.DeviceMessage
if err := json.Unmarshal(msg.Value, &m); err != nil { if err := jsoniter.Unmarshal(msg.Value, &m); err != nil {
log.WithError(err).Errorf("failed to read device message from key change topic") log.WithError(err).Errorf("failed to read device message from key change topic")
return nil return nil
} }
@ -122,7 +122,7 @@ func (t *KeyChangeConsumer) onMessage(msg *sarama.ConsumerMessage) error {
Deleted: len(m.KeyJSON) == 0, Deleted: len(m.KeyJSON) == 0,
Keys: m.KeyJSON, Keys: m.KeyJSON,
} }
if edu.Content, err = json.Marshal(event); err != nil { if edu.Content, err = jsoniter.Marshal(event); err != nil {
return err return err
} }

4
federationsender/consumers/roomserver.go
View file

@ -16,7 +16,7 @@ package consumers
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
@ -77,7 +77,7 @@ func (s *OutputRoomEventConsumer) Start() error {
func (s *OutputRoomEventConsumer) onMessage(msg *sarama.ConsumerMessage) error { func (s *OutputRoomEventConsumer) onMessage(msg *sarama.ConsumerMessage) error {
// Parse out the event JSON // Parse out the event JSON
var output api.OutputEvent var output api.OutputEvent
if err := json.Unmarshal(msg.Value, &output); err != nil { if err := jsoniter.Unmarshal(msg.Value, &output); err != nil {
// If the message was invalid, log it and move on to the next message in the stream // If the message was invalid, log it and move on to the next message in the stream
log.WithError(err).Errorf("roomserver output log: message parse failure") log.WithError(err).Errorf("roomserver output log: message parse failure")
return nil return nil

34
federationsender/inthttp/server.go
View file

@ -1,7 +1,7 @@
package inthttp package inthttp
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/gorilla/mux" "github.com/gorilla/mux"
@ -18,7 +18,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
httputil.MakeInternalAPI("QueryJoinedHostServerNamesInRoom", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("QueryJoinedHostServerNamesInRoom", func(req *http.Request) util.JSONResponse {
var request api.QueryJoinedHostServerNamesInRoomRequest var request api.QueryJoinedHostServerNamesInRoomRequest
var response api.QueryJoinedHostServerNamesInRoomResponse var response api.QueryJoinedHostServerNamesInRoomResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := intAPI.QueryJoinedHostServerNamesInRoom(req.Context(), &request, &response); err != nil { if err := intAPI.QueryJoinedHostServerNamesInRoom(req.Context(), &request, &response); err != nil {
@ -32,7 +32,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
httputil.MakeInternalAPI("PerformJoinRequest", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("PerformJoinRequest", func(req *http.Request) util.JSONResponse {
var request api.PerformJoinRequest var request api.PerformJoinRequest
var response api.PerformJoinResponse var response api.PerformJoinResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
intAPI.PerformJoin(req.Context(), &request, &response) intAPI.PerformJoin(req.Context(), &request, &response)
@ -44,7 +44,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
httputil.MakeInternalAPI("PerformLeaveRequest", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("PerformLeaveRequest", func(req *http.Request) util.JSONResponse {
var request api.PerformLeaveRequest var request api.PerformLeaveRequest
var response api.PerformLeaveResponse var response api.PerformLeaveResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := intAPI.PerformLeave(req.Context(), &request, &response); err != nil { if err := intAPI.PerformLeave(req.Context(), &request, &response); err != nil {
@ -58,7 +58,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
httputil.MakeInternalAPI("PerformInviteRequest", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("PerformInviteRequest", func(req *http.Request) util.JSONResponse {
var request api.PerformInviteRequest var request api.PerformInviteRequest
var response api.PerformInviteResponse var response api.PerformInviteResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := intAPI.PerformInvite(req.Context(), &request, &response); err != nil { if err := intAPI.PerformInvite(req.Context(), &request, &response); err != nil {
@ -72,7 +72,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
httputil.MakeInternalAPI("PerformDirectoryLookupRequest", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("PerformDirectoryLookupRequest", func(req *http.Request) util.JSONResponse {
var request api.PerformDirectoryLookupRequest var request api.PerformDirectoryLookupRequest
var response api.PerformDirectoryLookupResponse var response api.PerformDirectoryLookupResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := intAPI.PerformDirectoryLookup(req.Context(), &request, &response); err != nil { if err := intAPI.PerformDirectoryLookup(req.Context(), &request, &response); err != nil {
@ -86,7 +86,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
httputil.MakeInternalAPI("PerformServersAliveRequest", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("PerformServersAliveRequest", func(req *http.Request) util.JSONResponse {
var request api.PerformServersAliveRequest var request api.PerformServersAliveRequest
var response api.PerformServersAliveResponse var response api.PerformServersAliveResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := intAPI.PerformServersAlive(req.Context(), &request, &response); err != nil { if err := intAPI.PerformServersAlive(req.Context(), &request, &response); err != nil {
@ -100,7 +100,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
httputil.MakeInternalAPI("PerformBroadcastEDU", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("PerformBroadcastEDU", func(req *http.Request) util.JSONResponse {
var request api.PerformBroadcastEDURequest var request api.PerformBroadcastEDURequest
var response api.PerformBroadcastEDUResponse var response api.PerformBroadcastEDUResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := intAPI.PerformBroadcastEDU(req.Context(), &request, &response); err != nil { if err := intAPI.PerformBroadcastEDU(req.Context(), &request, &response); err != nil {
@ -113,7 +113,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
FederationSenderGetUserDevicesPath, FederationSenderGetUserDevicesPath,
httputil.MakeInternalAPI("GetUserDevices", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("GetUserDevices", func(req *http.Request) util.JSONResponse {
var request getUserDevices var request getUserDevices
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
res, err := intAPI.GetUserDevices(req.Context(), request.S, request.UserID) res, err := intAPI.GetUserDevices(req.Context(), request.S, request.UserID)
@ -135,7 +135,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
FederationSenderClaimKeysPath, FederationSenderClaimKeysPath,
httputil.MakeInternalAPI("ClaimKeys", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("ClaimKeys", func(req *http.Request) util.JSONResponse {
var request claimKeys var request claimKeys
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
res, err := intAPI.ClaimKeys(req.Context(), request.S, request.OneTimeKeys) res, err := intAPI.ClaimKeys(req.Context(), request.S, request.OneTimeKeys)
@ -157,7 +157,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
FederationSenderQueryKeysPath, FederationSenderQueryKeysPath,
httputil.MakeInternalAPI("QueryKeys", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("QueryKeys", func(req *http.Request) util.JSONResponse {
var request queryKeys var request queryKeys
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
res, err := intAPI.QueryKeys(req.Context(), request.S, request.Keys) res, err := intAPI.QueryKeys(req.Context(), request.S, request.Keys)
@ -179,7 +179,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
FederationSenderBackfillPath, FederationSenderBackfillPath,
httputil.MakeInternalAPI("Backfill", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("Backfill", func(req *http.Request) util.JSONResponse {
var request backfill var request backfill
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
res, err := intAPI.Backfill(req.Context(), request.S, request.RoomID, request.Limit, request.EventIDs) res, err := intAPI.Backfill(req.Context(), request.S, request.RoomID, request.Limit, request.EventIDs)
@ -201,7 +201,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
FederationSenderLookupStatePath, FederationSenderLookupStatePath,
httputil.MakeInternalAPI("LookupState", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("LookupState", func(req *http.Request) util.JSONResponse {
var request lookupState var request lookupState
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
res, err := intAPI.LookupState(req.Context(), request.S, request.RoomID, request.EventID, request.RoomVersion) res, err := intAPI.LookupState(req.Context(), request.S, request.RoomID, request.EventID, request.RoomVersion)
@ -223,7 +223,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
FederationSenderLookupStateIDsPath, FederationSenderLookupStateIDsPath,
httputil.MakeInternalAPI("LookupStateIDs", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("LookupStateIDs", func(req *http.Request) util.JSONResponse {
var request lookupStateIDs var request lookupStateIDs
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
res, err := intAPI.LookupStateIDs(req.Context(), request.S, request.RoomID, request.EventID) res, err := intAPI.LookupStateIDs(req.Context(), request.S, request.RoomID, request.EventID)
@ -245,7 +245,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
FederationSenderGetEventPath, FederationSenderGetEventPath,
httputil.MakeInternalAPI("GetEvent", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("GetEvent", func(req *http.Request) util.JSONResponse {
var request getEvent var request getEvent
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
res, err := intAPI.GetEvent(req.Context(), request.S, request.EventID) res, err := intAPI.GetEvent(req.Context(), request.S, request.EventID)
@ -267,7 +267,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
FederationSenderGetServerKeysPath, FederationSenderGetServerKeysPath,
httputil.MakeInternalAPI("GetServerKeys", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("GetServerKeys", func(req *http.Request) util.JSONResponse {
var request getServerKeys var request getServerKeys
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
res, err := intAPI.GetServerKeys(req.Context(), request.S) res, err := intAPI.GetServerKeys(req.Context(), request.S)
@ -289,7 +289,7 @@ func AddRoutes(intAPI api.FederationSenderInternalAPI, internalAPIMux *mux.Route
FederationSenderLookupServerKeysPath, FederationSenderLookupServerKeysPath,
httputil.MakeInternalAPI("LookupServerKeys", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("LookupServerKeys", func(req *http.Request) util.JSONResponse {
var request lookupServerKeys var request lookupServerKeys
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
res, err := intAPI.LookupServerKeys(req.Context(), request.S, request.KeyRequests) res, err := intAPI.LookupServerKeys(req.Context(), request.S, request.KeyRequests)

2
federationsender/queue/destinationqueue.go
View file

@ -333,7 +333,7 @@ func (oq *destinationQueue) nextTransaction() (bool, error) {
// Go through PDUs that we retrieved from the database, if any, // Go through PDUs that we retrieved from the database, if any,
// and add them into the transaction. // and add them into the transaction.
for _, pdu := range pdus { for _, pdu := range pdus {
// Append the JSON of the event, since this is a json.RawMessage type in the // Append the JSON of the event, since this is a jsoniter.RawMessage type in the
// gomatrixserverlib.Transaction struct // gomatrixserverlib.Transaction struct
t.PDUs = append(t.PDUs, (*pdu).JSON()) t.PDUs = append(t.PDUs, (*pdu).JSON())
} }

10
federationsender/queue/queue.go
View file

@ -17,7 +17,7 @@ package queue
import ( import (
"context" "context"
"crypto/ed25519" "crypto/ed25519"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"sync" "sync"
"time" "time"
@ -159,9 +159,9 @@ func (oqs *OutgoingQueues) SendEvent(
"destinations": len(destmap), "event": ev.EventID(), "destinations": len(destmap), "event": ev.EventID(),
}).Infof("Sending event") }).Infof("Sending event")
headeredJSON, err := json.Marshal(ev) headeredJSON, err := jsoniter.Marshal(ev)
if err != nil { if err != nil {
return fmt.Errorf("json.Marshal: %w", err) return fmt.Errorf("jsoniter.Marshal: %w", err)
} }
nid, err := oqs.db.StoreJSON(context.TODO(), string(headeredJSON)) nid, err := oqs.db.StoreJSON(context.TODO(), string(headeredJSON))
@ -224,9 +224,9 @@ func (oqs *OutgoingQueues) SendEDU(
"destinations": len(destmap), "edu_type": e.Type, "destinations": len(destmap), "edu_type": e.Type,
}).Info("Sending EDU event") }).Info("Sending EDU event")
ephemeralJSON, err := json.Marshal(e) ephemeralJSON, err := jsoniter.Marshal(e)
if err != nil { if err != nil {
return fmt.Errorf("json.Marshal: %w", err) return fmt.Errorf("jsoniter.Marshal: %w", err)
} }
nid, err := oqs.db.StoreJSON(context.TODO(), string(ephemeralJSON)) nid, err := oqs.db.StoreJSON(context.TODO(), string(ephemeralJSON))

4
federationsender/storage/shared/storage.go
View file

@ -17,7 +17,7 @@ package shared
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"github.com/matrix-org/dendrite/federationsender/storage/tables" "github.com/matrix-org/dendrite/federationsender/storage/tables"
@ -50,7 +50,7 @@ func (e *Receipt) Empty() bool {
} }
func (e *Receipt) String() string { func (e *Receipt) String() string {
j, _ := json.Marshal(e.nids) j, _ := jsoniter.Marshal(e.nids)
return string(j) return string(j)
} }

4
federationsender/storage/shared/storage_edus.go
View file

@ -17,7 +17,7 @@ package shared
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"errors" "errors"
"fmt" "fmt"
@ -76,7 +76,7 @@ func (d *Database) GetNextTransactionEDUs(
for _, blob := range blobs { for _, blob := range blobs {
var event gomatrixserverlib.EDU var event gomatrixserverlib.EDU
if err := json.Unmarshal(blob, &event); err != nil { if err := jsoniter.Unmarshal(blob, &event); err != nil {
return fmt.Errorf("json.Unmarshal: %w", err) return fmt.Errorf("json.Unmarshal: %w", err)
} }
edus = append(edus, &event) edus = append(edus, &event)

4
federationsender/storage/shared/storage_pdus.go
View file

@ -17,7 +17,7 @@ package shared
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"errors" "errors"
"fmt" "fmt"
@ -92,7 +92,7 @@ func (d *Database) GetNextTransactionPDUs(
for _, blob := range blobs { for _, blob := range blobs {
var event gomatrixserverlib.HeaderedEvent var event gomatrixserverlib.HeaderedEvent
if err := json.Unmarshal(blob, &event); err != nil { if err := jsoniter.Unmarshal(blob, &event); err != nil {
return fmt.Errorf("json.Unmarshal: %w", err) return fmt.Errorf("json.Unmarshal: %w", err)
} }
events = append(events, &event) events = append(events, &event)

1
go.mod
View file

@ -7,6 +7,7 @@ require (
github.com/gologme/log v1.2.0 github.com/gologme/log v1.2.0
github.com/gorilla/mux v1.8.0 github.com/gorilla/mux v1.8.0
github.com/hashicorp/golang-lru v0.5.4 github.com/hashicorp/golang-lru v0.5.4
github.com/json-iterator/go v1.1.10
github.com/lib/pq v1.8.0 github.com/lib/pq v1.8.0
github.com/libp2p/go-libp2p v0.11.0 github.com/libp2p/go-libp2p v0.11.0
github.com/libp2p/go-libp2p-circuit v0.3.1 github.com/libp2p/go-libp2p-circuit v0.3.1

3
go.sum
View file

@ -282,6 +282,7 @@ github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M
github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/json-iterator/go v1.1.10 h1:Kz6Cvnvv2wGdaG/V8yMvfkmNiXq9Ya2KUv4rouJJr68=
github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
@ -609,8 +610,10 @@ github.com/minio/sha256-simd v0.1.1/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8= github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
github.com/mr-tron/base58 v1.1.1/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8= github.com/mr-tron/base58 v1.1.1/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=

8
internal/httputil/http.go
View file

@ -17,7 +17,7 @@ package httputil
import ( import (
"bytes" "bytes"
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"net/http" "net/http"
"net/url" "net/url"
@ -32,7 +32,7 @@ func PostJSON(
ctx context.Context, span opentracing.Span, httpClient *http.Client, ctx context.Context, span opentracing.Span, httpClient *http.Client,
apiURL string, request, response interface{}, apiURL string, request, response interface{},
) error { ) error {
jsonBytes, err := json.Marshal(request) jsonBytes, err := jsoniter.Marshal(request)
if err != nil { if err != nil {
return err return err
} }
@ -72,10 +72,10 @@ func PostJSON(
var errorBody struct { var errorBody struct {
Message string `json:"message"` Message string `json:"message"`
} }
if msgerr := json.NewDecoder(res.Body).Decode(&errorBody); msgerr == nil { if msgerr := jsoniter.NewDecoder(res.Body).Decode(&errorBody); msgerr == nil {
return fmt.Errorf("Internal API: %d from %s: %s", res.StatusCode, apiURL, errorBody.Message) return fmt.Errorf("Internal API: %d from %s: %s", res.StatusCode, apiURL, errorBody.Message)
} }
return fmt.Errorf("Internal API: %d from %s", res.StatusCode, apiURL) return fmt.Errorf("Internal API: %d from %s", res.StatusCode, apiURL)
} }
return json.NewDecoder(res.Body).Decode(response) return jsoniter.NewDecoder(res.Body).Decode(response)
} }

8
keyserver/api/api.go
View file

@ -16,7 +16,7 @@ package api
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"strings" "strings"
"time" "time"
@ -83,7 +83,7 @@ type OneTimeKeys struct {
// The device ID of this device // The device ID of this device
DeviceID string DeviceID string
// A map of algorithm:key_id => key JSON // A map of algorithm:key_id => key JSON
KeyJSON map[string]json.RawMessage KeyJSON map[string]jsoniter.RawMessage
} }
// Split a key in KeyJSON into algorithm and key ID // Split a key in KeyJSON into algorithm and key ID
@ -142,7 +142,7 @@ type PerformClaimKeysRequest struct {
type PerformClaimKeysResponse struct { type PerformClaimKeysResponse struct {
// Map of user_id to device_id to algorithm:key_id to key JSON // Map of user_id to device_id to algorithm:key_id to key JSON
OneTimeKeys map[string]map[string]map[string]json.RawMessage OneTimeKeys map[string]map[string]map[string]jsoniter.RawMessage
// Map of remote server domain to error JSON // Map of remote server domain to error JSON
Failures map[string]interface{} Failures map[string]interface{}
// Set if there was a fatal error processing this action // Set if there was a fatal error processing this action
@ -159,7 +159,7 @@ type QueryKeysResponse struct {
// Map of remote server domain to error JSON // Map of remote server domain to error JSON
Failures map[string]interface{} Failures map[string]interface{}
// Map of user_id to device_id to device_key // Map of user_id to device_id to device_key
DeviceKeys map[string]map[string]json.RawMessage DeviceKeys map[string]map[string]jsoniter.RawMessage
// Set if there was a fatal error processing this query // Set if there was a fatal error processing this query
Error *KeyError Error *KeyError
} }

4
keyserver/internal/device_list_update.go
View file

@ -16,7 +16,7 @@ package internal
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"hash/fnv" "hash/fnv"
"sync" "sync"
@ -369,7 +369,7 @@ func (u *DeviceListUpdater) updateDeviceList(res *gomatrixserverlib.RespUserDevi
keys := make([]api.DeviceMessage, len(res.Devices)) keys := make([]api.DeviceMessage, len(res.Devices))
existingKeys := make([]api.DeviceMessage, len(res.Devices)) existingKeys := make([]api.DeviceMessage, len(res.Devices))
for i, device := range res.Devices { for i, device := range res.Devices {
keyJSON, err := json.Marshal(device.Keys) keyJSON, err := jsoniter.Marshal(device.Keys)
if err != nil { if err != nil {
util.GetLogger(ctx).WithField("keys", device.Keys).Error("failed to marshal keys, skipping device") util.GetLogger(ctx).WithField("keys", device.Keys).Error("failed to marshal keys, skipping device")
continue continue

24
keyserver/internal/internal.go
View file

@ -17,7 +17,7 @@ package internal
import ( import (
"bytes" "bytes"
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"sync" "sync"
"time" "time"
@ -80,7 +80,7 @@ func (a *KeyInternalAPI) PerformUploadKeys(ctx context.Context, req *api.Perform
} }
func (a *KeyInternalAPI) PerformClaimKeys(ctx context.Context, req *api.PerformClaimKeysRequest, res *api.PerformClaimKeysResponse) { func (a *KeyInternalAPI) PerformClaimKeys(ctx context.Context, req *api.PerformClaimKeysRequest, res *api.PerformClaimKeysResponse) {
res.OneTimeKeys = make(map[string]map[string]map[string]json.RawMessage) res.OneTimeKeys = make(map[string]map[string]map[string]jsoniter.RawMessage)
res.Failures = make(map[string]interface{}) res.Failures = make(map[string]interface{})
// wrap request map in a top-level by-domain map // wrap request map in a top-level by-domain map
domainToDeviceKeys := make(map[string]map[string]map[string]string) domainToDeviceKeys := make(map[string]map[string]map[string]string)
@ -108,11 +108,11 @@ func (a *KeyInternalAPI) PerformClaimKeys(ctx context.Context, req *api.PerformC
for _, key := range keys { for _, key := range keys {
_, ok := res.OneTimeKeys[key.UserID] _, ok := res.OneTimeKeys[key.UserID]
if !ok { if !ok {
res.OneTimeKeys[key.UserID] = make(map[string]map[string]json.RawMessage) res.OneTimeKeys[key.UserID] = make(map[string]map[string]jsoniter.RawMessage)
} }
_, ok = res.OneTimeKeys[key.UserID][key.DeviceID] _, ok = res.OneTimeKeys[key.UserID][key.DeviceID]
if !ok { if !ok {
res.OneTimeKeys[key.UserID][key.DeviceID] = make(map[string]json.RawMessage) res.OneTimeKeys[key.UserID][key.DeviceID] = make(map[string]jsoniter.RawMessage)
} }
for keyID, keyJSON := range key.KeyJSON { for keyID, keyJSON := range key.KeyJSON {
res.OneTimeKeys[key.UserID][key.DeviceID][keyID] = keyJSON res.OneTimeKeys[key.UserID][key.DeviceID][keyID] = keyJSON
@ -165,11 +165,11 @@ func (a *KeyInternalAPI) claimRemoteKeys(
keysClaimed := 0 keysClaimed := 0
for result := range resultCh { for result := range resultCh {
for userID, nest := range result.OneTimeKeys { for userID, nest := range result.OneTimeKeys {
res.OneTimeKeys[userID] = make(map[string]map[string]json.RawMessage) res.OneTimeKeys[userID] = make(map[string]map[string]jsoniter.RawMessage)
for deviceID, nest2 := range nest { for deviceID, nest2 := range nest {
res.OneTimeKeys[userID][deviceID] = make(map[string]json.RawMessage) res.OneTimeKeys[userID][deviceID] = make(map[string]jsoniter.RawMessage)
for keyIDWithAlgo, otk := range nest2 { for keyIDWithAlgo, otk := range nest2 {
keyJSON, err := json.Marshal(otk) keyJSON, err := jsoniter.Marshal(otk)
if err != nil { if err != nil {
continue continue
} }
@ -220,7 +220,7 @@ func (a *KeyInternalAPI) QueryDeviceMessages(ctx context.Context, req *api.Query
} }
func (a *KeyInternalAPI) QueryKeys(ctx context.Context, req *api.QueryKeysRequest, res *api.QueryKeysResponse) { func (a *KeyInternalAPI) QueryKeys(ctx context.Context, req *api.QueryKeysRequest, res *api.QueryKeysResponse) {
res.DeviceKeys = make(map[string]map[string]json.RawMessage) res.DeviceKeys = make(map[string]map[string]jsoniter.RawMessage)
res.Failures = make(map[string]interface{}) res.Failures = make(map[string]interface{})
// make a map from domain to device keys // make a map from domain to device keys
domainToDeviceKeys := make(map[string]map[string][]string) domainToDeviceKeys := make(map[string]map[string][]string)
@ -254,7 +254,7 @@ func (a *KeyInternalAPI) QueryKeys(ctx context.Context, req *api.QueryKeysReques
} }
if res.DeviceKeys[userID] == nil { if res.DeviceKeys[userID] == nil {
res.DeviceKeys[userID] = make(map[string]json.RawMessage) res.DeviceKeys[userID] = make(map[string]jsoniter.RawMessage)
} }
for _, dk := range deviceKeys { for _, dk := range deviceKeys {
if len(dk.KeyJSON) == 0 { if len(dk.KeyJSON) == 0 {
@ -335,9 +335,9 @@ func (a *KeyInternalAPI) queryRemoteKeys(
for result := range resultCh { for result := range resultCh {
for userID, nest := range result.DeviceKeys { for userID, nest := range result.DeviceKeys {
res.DeviceKeys[userID] = make(map[string]json.RawMessage) res.DeviceKeys[userID] = make(map[string]jsoniter.RawMessage)
for deviceID, deviceKey := range nest { for deviceID, deviceKey := range nest {
keyJSON, err := json.Marshal(deviceKey) keyJSON, err := jsoniter.Marshal(deviceKey)
if err != nil { if err != nil {
continue continue
} }
@ -432,7 +432,7 @@ func (a *KeyInternalAPI) populateResponseWithDeviceKeysFromDatabase(
return fmt.Errorf("DeviceKeysForUser %s returned no keys but wanted all keys, falling back to remote", userID) return fmt.Errorf("DeviceKeysForUser %s returned no keys but wanted all keys, falling back to remote", userID)
} }
if res.DeviceKeys[userID] == nil { if res.DeviceKeys[userID] == nil {
res.DeviceKeys[userID] = make(map[string]json.RawMessage) res.DeviceKeys[userID] = make(map[string]jsoniter.RawMessage)
} }
for _, key := range keys { for _, key := range keys {

16
keyserver/inthttp/server.go
View file

@ -15,7 +15,7 @@
package inthttp package inthttp
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/gorilla/mux" "github.com/gorilla/mux"
@ -29,7 +29,7 @@ func AddRoutes(internalAPIMux *mux.Router, s api.KeyInternalAPI) {
httputil.MakeInternalAPI("inputDeviceListUpdate", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("inputDeviceListUpdate", func(req *http.Request) util.JSONResponse {
request := api.InputDeviceListUpdateRequest{} request := api.InputDeviceListUpdateRequest{}
response := api.InputDeviceListUpdateResponse{} response := api.InputDeviceListUpdateResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
s.InputDeviceListUpdate(req.Context(), &request, &response) s.InputDeviceListUpdate(req.Context(), &request, &response)
@ -40,7 +40,7 @@ func AddRoutes(internalAPIMux *mux.Router, s api.KeyInternalAPI) {
httputil.MakeInternalAPI("performClaimKeys", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("performClaimKeys", func(req *http.Request) util.JSONResponse {
request := api.PerformClaimKeysRequest{} request := api.PerformClaimKeysRequest{}
response := api.PerformClaimKeysResponse{} response := api.PerformClaimKeysResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
s.PerformClaimKeys(req.Context(), &request, &response) s.PerformClaimKeys(req.Context(), &request, &response)
@ -51,7 +51,7 @@ func AddRoutes(internalAPIMux *mux.Router, s api.KeyInternalAPI) {
httputil.MakeInternalAPI("performUploadKeys", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("performUploadKeys", func(req *http.Request) util.JSONResponse {
request := api.PerformUploadKeysRequest{} request := api.PerformUploadKeysRequest{}
response := api.PerformUploadKeysResponse{} response := api.PerformUploadKeysResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
s.PerformUploadKeys(req.Context(), &request, &response) s.PerformUploadKeys(req.Context(), &request, &response)
@ -62,7 +62,7 @@ func AddRoutes(internalAPIMux *mux.Router, s api.KeyInternalAPI) {
httputil.MakeInternalAPI("queryKeys", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryKeys", func(req *http.Request) util.JSONResponse {
request := api.QueryKeysRequest{} request := api.QueryKeysRequest{}
response := api.QueryKeysResponse{} response := api.QueryKeysResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
s.QueryKeys(req.Context(), &request, &response) s.QueryKeys(req.Context(), &request, &response)
@ -73,7 +73,7 @@ func AddRoutes(internalAPIMux *mux.Router, s api.KeyInternalAPI) {
httputil.MakeInternalAPI("queryOneTimeKeys", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryOneTimeKeys", func(req *http.Request) util.JSONResponse {
request := api.QueryOneTimeKeysRequest{} request := api.QueryOneTimeKeysRequest{}
response := api.QueryOneTimeKeysResponse{} response := api.QueryOneTimeKeysResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
s.QueryOneTimeKeys(req.Context(), &request, &response) s.QueryOneTimeKeys(req.Context(), &request, &response)
@ -84,7 +84,7 @@ func AddRoutes(internalAPIMux *mux.Router, s api.KeyInternalAPI) {
httputil.MakeInternalAPI("queryDeviceMessages", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryDeviceMessages", func(req *http.Request) util.JSONResponse {
request := api.QueryDeviceMessagesRequest{} request := api.QueryDeviceMessagesRequest{}
response := api.QueryDeviceMessagesResponse{} response := api.QueryDeviceMessagesResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
s.QueryDeviceMessages(req.Context(), &request, &response) s.QueryDeviceMessages(req.Context(), &request, &response)
@ -95,7 +95,7 @@ func AddRoutes(internalAPIMux *mux.Router, s api.KeyInternalAPI) {
httputil.MakeInternalAPI("queryKeyChanges", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryKeyChanges", func(req *http.Request) util.JSONResponse {
request := api.QueryKeyChangesRequest{} request := api.QueryKeyChangesRequest{}
response := api.QueryKeyChangesResponse{} response := api.QueryKeyChangesResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
s.QueryKeyChanges(req.Context(), &request, &response) s.QueryKeyChanges(req.Context(), &request, &response)

4
keyserver/producers/keychange.go
View file

@ -16,7 +16,7 @@ package producers
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
"github.com/matrix-org/dendrite/keyserver/api" "github.com/matrix-org/dendrite/keyserver/api"
@ -46,7 +46,7 @@ func (p *KeyChange) ProduceKeyChanges(keys []api.DeviceMessage) error {
for _, key := range keys { for _, key := range keys {
var m sarama.ProducerMessage var m sarama.ProducerMessage
value, err := json.Marshal(key) value, err := jsoniter.Marshal(key)
if err != nil { if err != nil {
return err return err
} }

5
keyserver/storage/interface.go
View file

@ -16,8 +16,7 @@ package storage
import ( import (
"context" "context"
"encoding/json" jsoniter "github.com/json-iterator/go"
"github.com/matrix-org/dendrite/keyserver/api" "github.com/matrix-org/dendrite/keyserver/api"
"github.com/matrix-org/gomatrixserverlib" "github.com/matrix-org/gomatrixserverlib"
) )
@ -25,7 +24,7 @@ import (
type Database interface { type Database interface {
// ExistingOneTimeKeys returns a map of keyIDWithAlgorithm to key JSON for the given parameters. If no keys exist with this combination // ExistingOneTimeKeys returns a map of keyIDWithAlgorithm to key JSON for the given parameters. If no keys exist with this combination
// of user/device/key/algorithm 4-uple then it is omitted from the map. Returns an error when failing to communicate with the database. // of user/device/key/algorithm 4-uple then it is omitted from the map. Returns an error when failing to communicate with the database.
ExistingOneTimeKeys(ctx context.Context, userID, deviceID string, keyIDsWithAlgorithms []string) (map[string]json.RawMessage, error) ExistingOneTimeKeys(ctx context.Context, userID, deviceID string, keyIDsWithAlgorithms []string) (map[string]jsoniter.RawMessage, error)
// StoreOneTimeKeys persists the given one-time keys. // StoreOneTimeKeys persists the given one-time keys.
StoreOneTimeKeys(ctx context.Context, keys api.OneTimeKeys) (*api.OneTimeKeysCount, error) StoreOneTimeKeys(ctx context.Context, keys api.OneTimeKeys) (*api.OneTimeKeysCount, error)

14
keyserver/storage/postgres/one_time_keys_table.go
View file

@ -17,7 +17,7 @@ package postgres
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"time" "time"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
@ -93,7 +93,7 @@ func NewPostgresOneTimeKeysTable(db *sql.DB) (tables.OneTimeKeys, error) {
return s, nil return s, nil
} }
func (s *oneTimeKeysStatements) SelectOneTimeKeys(ctx context.Context, userID, deviceID string, keyIDsWithAlgorithms []string) (map[string]json.RawMessage, error) { func (s *oneTimeKeysStatements) SelectOneTimeKeys(ctx context.Context, userID, deviceID string, keyIDsWithAlgorithms []string) (map[string]jsoniter.RawMessage, error) {
rows, err := s.selectKeysStmt.QueryContext(ctx, userID, deviceID) rows, err := s.selectKeysStmt.QueryContext(ctx, userID, deviceID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -105,7 +105,7 @@ func (s *oneTimeKeysStatements) SelectOneTimeKeys(ctx context.Context, userID, d
wantSet[ka] = true wantSet[ka] = true
} }
result := make(map[string]json.RawMessage) result := make(map[string]jsoniter.RawMessage)
for rows.Next() { for rows.Next() {
var keyID string var keyID string
var algorithm string var algorithm string
@ -115,7 +115,7 @@ func (s *oneTimeKeysStatements) SelectOneTimeKeys(ctx context.Context, userID, d
} }
keyIDWithAlgo := algorithm + ":" + keyID keyIDWithAlgo := algorithm + ":" + keyID
if wantSet[keyIDWithAlgo] { if wantSet[keyIDWithAlgo] {
result[keyIDWithAlgo] = json.RawMessage(keyJSONStr) result[keyIDWithAlgo] = jsoniter.RawMessage(keyJSONStr)
} }
} }
return result, rows.Err() return result, rows.Err()
@ -178,7 +178,7 @@ func (s *oneTimeKeysStatements) InsertOneTimeKeys(ctx context.Context, txn *sql.
func (s *oneTimeKeysStatements) SelectAndDeleteOneTimeKey( func (s *oneTimeKeysStatements) SelectAndDeleteOneTimeKey(
ctx context.Context, txn *sql.Tx, userID, deviceID, algorithm string, ctx context.Context, txn *sql.Tx, userID, deviceID, algorithm string,
) (map[string]json.RawMessage, error) { ) (map[string]jsoniter.RawMessage, error) {
var keyID string var keyID string
var keyJSON string var keyJSON string
err := sqlutil.TxStmtContext(ctx, txn, s.selectKeyByAlgorithmStmt).QueryRowContext(ctx, userID, deviceID, algorithm).Scan(&keyID, &keyJSON) err := sqlutil.TxStmtContext(ctx, txn, s.selectKeyByAlgorithmStmt).QueryRowContext(ctx, userID, deviceID, algorithm).Scan(&keyID, &keyJSON)
@ -189,7 +189,7 @@ func (s *oneTimeKeysStatements) SelectAndDeleteOneTimeKey(
return nil, err return nil, err
} }
_, err = sqlutil.TxStmtContext(ctx, txn, s.deleteOneTimeKeyStmt).ExecContext(ctx, userID, deviceID, algorithm, keyID) _, err = sqlutil.TxStmtContext(ctx, txn, s.deleteOneTimeKeyStmt).ExecContext(ctx, userID, deviceID, algorithm, keyID)
return map[string]json.RawMessage{ return map[string]jsoniter.RawMessage{
algorithm + ":" + keyID: json.RawMessage(keyJSON), algorithm + ":" + keyID: jsoniter.RawMessage(keyJSON),
}, err }, err
} }

4
keyserver/storage/shared/storage.go
View file

@ -17,7 +17,7 @@ package shared
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"github.com/matrix-org/dendrite/internal/sqlutil" "github.com/matrix-org/dendrite/internal/sqlutil"
"github.com/matrix-org/dendrite/keyserver/api" "github.com/matrix-org/dendrite/keyserver/api"
@ -34,7 +34,7 @@ type Database struct {
StaleDeviceListsTable tables.StaleDeviceLists StaleDeviceListsTable tables.StaleDeviceLists
} }
func (d *Database) ExistingOneTimeKeys(ctx context.Context, userID, deviceID string, keyIDsWithAlgorithms []string) (map[string]json.RawMessage, error) { func (d *Database) ExistingOneTimeKeys(ctx context.Context, userID, deviceID string, keyIDsWithAlgorithms []string) (map[string]jsoniter.RawMessage, error) {
return d.OneTimeKeysTable.SelectOneTimeKeys(ctx, userID, deviceID, keyIDsWithAlgorithms) return d.OneTimeKeysTable.SelectOneTimeKeys(ctx, userID, deviceID, keyIDsWithAlgorithms)
} }

14
keyserver/storage/sqlite3/one_time_keys_table.go
View file

@ -17,7 +17,7 @@ package sqlite3
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"time" "time"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
@ -93,7 +93,7 @@ func NewSqliteOneTimeKeysTable(db *sql.DB) (tables.OneTimeKeys, error) {
return s, nil return s, nil
} }
func (s *oneTimeKeysStatements) SelectOneTimeKeys(ctx context.Context, userID, deviceID string, keyIDsWithAlgorithms []string) (map[string]json.RawMessage, error) { func (s *oneTimeKeysStatements) SelectOneTimeKeys(ctx context.Context, userID, deviceID string, keyIDsWithAlgorithms []string) (map[string]jsoniter.RawMessage, error) {
rows, err := s.selectKeysStmt.QueryContext(ctx, userID, deviceID) rows, err := s.selectKeysStmt.QueryContext(ctx, userID, deviceID)
if err != nil { if err != nil {
return nil, err return nil, err
@ -105,7 +105,7 @@ func (s *oneTimeKeysStatements) SelectOneTimeKeys(ctx context.Context, userID, d
wantSet[ka] = true wantSet[ka] = true
} }
result := make(map[string]json.RawMessage) result := make(map[string]jsoniter.RawMessage)
for rows.Next() { for rows.Next() {
var keyID string var keyID string
var algorithm string var algorithm string
@ -115,7 +115,7 @@ func (s *oneTimeKeysStatements) SelectOneTimeKeys(ctx context.Context, userID, d
} }
keyIDWithAlgo := algorithm + ":" + keyID keyIDWithAlgo := algorithm + ":" + keyID
if wantSet[keyIDWithAlgo] { if wantSet[keyIDWithAlgo] {
result[keyIDWithAlgo] = json.RawMessage(keyJSONStr) result[keyIDWithAlgo] = jsoniter.RawMessage(keyJSONStr)
} }
} }
return result, rows.Err() return result, rows.Err()
@ -180,7 +180,7 @@ func (s *oneTimeKeysStatements) InsertOneTimeKeys(
func (s *oneTimeKeysStatements) SelectAndDeleteOneTimeKey( func (s *oneTimeKeysStatements) SelectAndDeleteOneTimeKey(
ctx context.Context, txn *sql.Tx, userID, deviceID, algorithm string, ctx context.Context, txn *sql.Tx, userID, deviceID, algorithm string,
) (map[string]json.RawMessage, error) { ) (map[string]jsoniter.RawMessage, error) {
var keyID string var keyID string
var keyJSON string var keyJSON string
err := sqlutil.TxStmtContext(ctx, txn, s.selectKeyByAlgorithmStmt).QueryRowContext(ctx, userID, deviceID, algorithm).Scan(&keyID, &keyJSON) err := sqlutil.TxStmtContext(ctx, txn, s.selectKeyByAlgorithmStmt).QueryRowContext(ctx, userID, deviceID, algorithm).Scan(&keyID, &keyJSON)
@ -197,7 +197,7 @@ func (s *oneTimeKeysStatements) SelectAndDeleteOneTimeKey(
if keyJSON == "" { if keyJSON == "" {
return nil, nil return nil, nil
} }
return map[string]json.RawMessage{ return map[string]jsoniter.RawMessage{
algorithm + ":" + keyID: json.RawMessage(keyJSON), algorithm + ":" + keyID: jsoniter.RawMessage(keyJSON),
}, err }, err
} }

7
keyserver/storage/tables/interface.go
View file

@ -17,19 +17,18 @@ package tables
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" jsoniter "github.com/json-iterator/go"
"github.com/matrix-org/dendrite/keyserver/api" "github.com/matrix-org/dendrite/keyserver/api"
"github.com/matrix-org/gomatrixserverlib" "github.com/matrix-org/gomatrixserverlib"
) )
type OneTimeKeys interface { type OneTimeKeys interface {
SelectOneTimeKeys(ctx context.Context, userID, deviceID string, keyIDsWithAlgorithms []string) (map[string]json.RawMessage, error) SelectOneTimeKeys(ctx context.Context, userID, deviceID string, keyIDsWithAlgorithms []string) (map[string]jsoniter.RawMessage, error)
CountOneTimeKeys(ctx context.Context, userID, deviceID string) (*api.OneTimeKeysCount, error) CountOneTimeKeys(ctx context.Context, userID, deviceID string) (*api.OneTimeKeysCount, error)
InsertOneTimeKeys(ctx context.Context, txn *sql.Tx, keys api.OneTimeKeys) (*api.OneTimeKeysCount, error) InsertOneTimeKeys(ctx context.Context, txn *sql.Tx, keys api.OneTimeKeys) (*api.OneTimeKeysCount, error)
// SelectAndDeleteOneTimeKey selects a single one time key matching the user/device/algorithm specified and returns the algo:key_id => JSON. // SelectAndDeleteOneTimeKey selects a single one time key matching the user/device/algorithm specified and returns the algo:key_id => JSON.
// Returns an empty map if the key does not exist. // Returns an empty map if the key does not exist.
SelectAndDeleteOneTimeKey(ctx context.Context, txn *sql.Tx, userID, deviceID, algorithm string) (map[string]json.RawMessage, error) SelectAndDeleteOneTimeKey(ctx context.Context, txn *sql.Tx, userID, deviceID, algorithm string) (map[string]jsoniter.RawMessage, error)
} }
type DeviceKeys interface { type DeviceKeys interface {

6
mediaapi/routing/download.go
View file

@ -16,7 +16,7 @@ package routing
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"io" "io"
"mime" "mime"
@ -146,12 +146,12 @@ func Download(
func (r *downloadRequest) jsonErrorResponse(w http.ResponseWriter, res util.JSONResponse) { func (r *downloadRequest) jsonErrorResponse(w http.ResponseWriter, res util.JSONResponse) {
// Marshal JSON response into raw bytes to send as the HTTP body // Marshal JSON response into raw bytes to send as the HTTP body
resBytes, err := json.Marshal(res.JSON) resBytes, err := jsoniter.Marshal(res.JSON)
if err != nil { if err != nil {
r.Logger.WithError(err).Error("Failed to marshal JSONResponse") r.Logger.WithError(err).Error("Failed to marshal JSONResponse")
// this should never fail to be marshalled so drop err to the floor // this should never fail to be marshalled so drop err to the floor
res = util.MessageResponse(http.StatusNotFound, "Download request failed: "+err.Error()) res = util.MessageResponse(http.StatusNotFound, "Download request failed: "+err.Error())
resBytes, _ = json.Marshal(res.JSON) resBytes, _ = jsoniter.Marshal(res.JSON)
} }
// Set status code and write the body // Set status code and write the body

4
roomserver/acls/acls.go
View file

@ -16,7 +16,7 @@ package acls
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"net" "net"
"regexp" "regexp"
@ -88,7 +88,7 @@ func compileACLRegex(orig string) (*regexp.Regexp, error) {
func (s *ServerACLs) OnServerACLUpdate(state *gomatrixserverlib.Event) { func (s *ServerACLs) OnServerACLUpdate(state *gomatrixserverlib.Event) {
acls := &serverACL{} acls := &serverACL{}
if err := json.Unmarshal(state.Content(), &acls.ServerACL); err != nil { if err := jsoniter.Unmarshal(state.Content(), &acls.ServerACL); err != nil {
logrus.WithError(err).Errorf("Failed to unmarshal state content for server ACLs") logrus.WithError(err).Errorf("Failed to unmarshal state content for server ACLs")
return return
} }

4
roomserver/api/api_trace.go
View file

@ -2,7 +2,7 @@ package api
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
fsAPI "github.com/matrix-org/dendrite/federationsender/api" fsAPI "github.com/matrix-org/dendrite/federationsender/api"
@ -306,7 +306,7 @@ func (t *RoomserverInternalAPITrace) QueryServerBannedFromRoom(ctx context.Conte
} }
func js(thing interface{}) string { func js(thing interface{}) string {
b, err := json.Marshal(thing) b, err := jsoniter.Marshal(thing)
if err != nil { if err != nil {
return fmt.Sprintf("Marshal error:%s", err) return fmt.Sprintf("Marshal error:%s", err)
} }

4
roomserver/api/perform.go
View file

@ -1,7 +1,7 @@
package api package api
import ( import (
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"net/http" "net/http"
@ -54,7 +54,7 @@ func (p *PerformError) JSONResponse() util.JSONResponse {
return util.JSONResponse{ return util.JSONResponse{
Code: p.RemoteCode, Code: p.RemoteCode,
// TODO: Should we assert this is in fact JSON? E.g gjson parse? // TODO: Should we assert this is in fact JSON? E.g gjson parse?
JSON: json.RawMessage(p.Msg), JSON: jsoniter.RawMessage(p.Msg),
} }
default: default:
return util.ErrorResponse(p) return util.ErrorResponse(p)

10
roomserver/api/query.go
View file

@ -17,7 +17,7 @@
package api package api
import ( import (
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"strings" "strings"
@ -351,12 +351,12 @@ func (r *QueryBulkStateContentResponse) MarshalJSON() ([]byte, error) {
se[fmt.Sprintf("%s\x1F%s\x1F%s", roomID, tuple.EventType, tuple.StateKey)] = event se[fmt.Sprintf("%s\x1F%s\x1F%s", roomID, tuple.EventType, tuple.StateKey)] = event
} }
} }
return json.Marshal(se) return jsoniter.Marshal(se)
} }
func (r *QueryBulkStateContentResponse) UnmarshalJSON(data []byte) error { func (r *QueryBulkStateContentResponse) UnmarshalJSON(data []byte) error {
wireFormat := make(map[string]string) wireFormat := make(map[string]string)
err := json.Unmarshal(data, &wireFormat) err := jsoniter.Unmarshal(data, &wireFormat)
if err != nil { if err != nil {
return err return err
} }
@ -382,12 +382,12 @@ func (r *QueryCurrentStateResponse) MarshalJSON() ([]byte, error) {
// use 0x1F (unit separator) as the delimiter between type/state key, // use 0x1F (unit separator) as the delimiter between type/state key,
se[fmt.Sprintf("%s\x1F%s", k.EventType, k.StateKey)] = v se[fmt.Sprintf("%s\x1F%s", k.EventType, k.StateKey)] = v
} }
return json.Marshal(se) return jsoniter.Marshal(se)
} }
func (r *QueryCurrentStateResponse) UnmarshalJSON(data []byte) error { func (r *QueryCurrentStateResponse) UnmarshalJSON(data []byte) error {
res := make(map[string]*gomatrixserverlib.HeaderedEvent) res := make(map[string]*gomatrixserverlib.HeaderedEvent)
err := json.Unmarshal(data, &res) err := jsoniter.Unmarshal(data, &res)
if err != nil { if err != nil {
return err return err
} }

4
roomserver/auth/auth.go
View file

@ -13,7 +13,7 @@
package auth package auth
import ( import (
"encoding/json" "github.com/json-iterator/go"
"github.com/matrix-org/gomatrixserverlib" "github.com/matrix-org/gomatrixserverlib"
) )
@ -65,7 +65,7 @@ func HistoryVisibilityForRoom(authEvents []gomatrixserverlib.Event) string {
content := struct { content := struct {
HistoryVisibility string `json:"history_visibility"` HistoryVisibility string `json:"history_visibility"`
}{} }{}
if err := json.Unmarshal(ev.Content(), &content); err != nil { if err := jsoniter.Unmarshal(ev.Content(), &content); err != nil {
break // value is not understood break // value is not understood
} }
for _, s := range knownStates { for _, s := range knownStates {

6
roomserver/internal/alias.go
View file

@ -16,7 +16,7 @@ package internal
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"errors" "errors"
"fmt" "fmt"
"time" "time"
@ -198,11 +198,11 @@ func (r *RoomserverInternalAPI) sendUpdatedAliasesEvent(
return err return err
} }
content := roomAliasesContent{Aliases: aliases} content := roomAliasesContent{Aliases: aliases}
rawContent, err := json.Marshal(content) rawContent, err := jsoniter.Marshal(content)
if err != nil { if err != nil {
return err return err
} }
err = builder.SetContent(json.RawMessage(rawContent)) err = builder.SetContent(jsoniter.RawMessage(rawContent))
if err != nil { if err != nil {
return err return err
} }

4
roomserver/internal/input/input.go
View file

@ -17,7 +17,7 @@ package input
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"sync" "sync"
"time" "time"
@ -73,7 +73,7 @@ func (w *inputWorker) start() {
func (r *Inputer) WriteOutputEvents(roomID string, updates []api.OutputEvent) error { func (r *Inputer) WriteOutputEvents(roomID string, updates []api.OutputEvent) error {
messages := make([]*sarama.ProducerMessage, len(updates)) messages := make([]*sarama.ProducerMessage, len(updates))
for i := range updates { for i := range updates {
value, err := json.Marshal(updates[i]) value, err := jsoniter.Marshal(updates[i])
if err != nil { if err != nil {
return err return err
} }

4
roomserver/internal/perform/perform_peek.go
View file

@ -16,7 +16,7 @@ package perform
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"strings" "strings"
@ -166,7 +166,7 @@ func (r *Peeker) performPeekRoomByID(
ev, _ := r.DB.GetStateEvent(ctx, roomID, "m.room.history_visibility", "") ev, _ := r.DB.GetStateEvent(ctx, roomID, "m.room.history_visibility", "")
if ev != nil { if ev != nil {
content := map[string]string{} content := map[string]string{}
if err = json.Unmarshal(ev.Content(), &content); err != nil { if err = jsoniter.Unmarshal(ev.Content(), &content); err != nil {
util.GetLogger(ctx).WithError(err).Error("json.Unmarshal for history visibility failed") util.GetLogger(ctx).WithError(err).Error("json.Unmarshal for history visibility failed")
return return
} }

4
roomserver/internal/query/query_test.go
View file

@ -16,7 +16,7 @@ package query
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"testing" "testing"
"github.com/matrix-org/dendrite/internal/test" "github.com/matrix-org/dendrite/internal/test"
@ -49,7 +49,7 @@ func (db *getEventDB) addFakeEvent(eventID string, authIDs []string) error {
"auth_events": authEvents, "auth_events": authEvents,
} }
eventJSON, err := json.Marshal(&builder) eventJSON, err := jsoniter.Marshal(&builder)
if err != nil { if err != nil {
return err return err
} }

64
roomserver/inthttp/server.go
View file

@ -1,7 +1,7 @@
package inthttp package inthttp
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/gorilla/mux" "github.com/gorilla/mux"
@ -17,7 +17,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("inputRoomEvents", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("inputRoomEvents", func(req *http.Request) util.JSONResponse {
var request api.InputRoomEventsRequest var request api.InputRoomEventsRequest
var response api.InputRoomEventsResponse var response api.InputRoomEventsResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
r.InputRoomEvents(req.Context(), &request, &response) r.InputRoomEvents(req.Context(), &request, &response)
@ -28,7 +28,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("performInvite", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("performInvite", func(req *http.Request) util.JSONResponse {
var request api.PerformInviteRequest var request api.PerformInviteRequest
var response api.PerformInviteResponse var response api.PerformInviteResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := r.PerformInvite(req.Context(), &request, &response); err != nil { if err := r.PerformInvite(req.Context(), &request, &response); err != nil {
@ -41,7 +41,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("performJoin", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("performJoin", func(req *http.Request) util.JSONResponse {
var request api.PerformJoinRequest var request api.PerformJoinRequest
var response api.PerformJoinResponse var response api.PerformJoinResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
r.PerformJoin(req.Context(), &request, &response) r.PerformJoin(req.Context(), &request, &response)
@ -52,7 +52,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("performLeave", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("performLeave", func(req *http.Request) util.JSONResponse {
var request api.PerformLeaveRequest var request api.PerformLeaveRequest
var response api.PerformLeaveResponse var response api.PerformLeaveResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := r.PerformLeave(req.Context(), &request, &response); err != nil { if err := r.PerformLeave(req.Context(), &request, &response); err != nil {
@ -65,7 +65,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("performPeek", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("performPeek", func(req *http.Request) util.JSONResponse {
var request api.PerformPeekRequest var request api.PerformPeekRequest
var response api.PerformPeekResponse var response api.PerformPeekResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
r.PerformPeek(req.Context(), &request, &response) r.PerformPeek(req.Context(), &request, &response)
@ -76,7 +76,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("performPublish", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("performPublish", func(req *http.Request) util.JSONResponse {
var request api.PerformPublishRequest var request api.PerformPublishRequest
var response api.PerformPublishResponse var response api.PerformPublishResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
r.PerformPublish(req.Context(), &request, &response) r.PerformPublish(req.Context(), &request, &response)
@ -88,7 +88,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryPublishedRooms", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryPublishedRooms", func(req *http.Request) util.JSONResponse {
var request api.QueryPublishedRoomsRequest var request api.QueryPublishedRoomsRequest
var response api.QueryPublishedRoomsResponse var response api.QueryPublishedRoomsResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryPublishedRooms(req.Context(), &request, &response); err != nil { if err := r.QueryPublishedRooms(req.Context(), &request, &response); err != nil {
@ -102,7 +102,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryLatestEventsAndState", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryLatestEventsAndState", func(req *http.Request) util.JSONResponse {
var request api.QueryLatestEventsAndStateRequest var request api.QueryLatestEventsAndStateRequest
var response api.QueryLatestEventsAndStateResponse var response api.QueryLatestEventsAndStateResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryLatestEventsAndState(req.Context(), &request, &response); err != nil { if err := r.QueryLatestEventsAndState(req.Context(), &request, &response); err != nil {
@ -116,7 +116,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryStateAfterEvents", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryStateAfterEvents", func(req *http.Request) util.JSONResponse {
var request api.QueryStateAfterEventsRequest var request api.QueryStateAfterEventsRequest
var response api.QueryStateAfterEventsResponse var response api.QueryStateAfterEventsResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryStateAfterEvents(req.Context(), &request, &response); err != nil { if err := r.QueryStateAfterEvents(req.Context(), &request, &response); err != nil {
@ -130,7 +130,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryMissingAuthPrevEvents", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryMissingAuthPrevEvents", func(req *http.Request) util.JSONResponse {
var request api.QueryMissingAuthPrevEventsRequest var request api.QueryMissingAuthPrevEventsRequest
var response api.QueryMissingAuthPrevEventsResponse var response api.QueryMissingAuthPrevEventsResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryMissingAuthPrevEvents(req.Context(), &request, &response); err != nil { if err := r.QueryMissingAuthPrevEvents(req.Context(), &request, &response); err != nil {
@ -144,7 +144,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryEventsByID", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryEventsByID", func(req *http.Request) util.JSONResponse {
var request api.QueryEventsByIDRequest var request api.QueryEventsByIDRequest
var response api.QueryEventsByIDResponse var response api.QueryEventsByIDResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryEventsByID(req.Context(), &request, &response); err != nil { if err := r.QueryEventsByID(req.Context(), &request, &response); err != nil {
@ -158,7 +158,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("QueryMembershipForUser", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("QueryMembershipForUser", func(req *http.Request) util.JSONResponse {
var request api.QueryMembershipForUserRequest var request api.QueryMembershipForUserRequest
var response api.QueryMembershipForUserResponse var response api.QueryMembershipForUserResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryMembershipForUser(req.Context(), &request, &response); err != nil { if err := r.QueryMembershipForUser(req.Context(), &request, &response); err != nil {
@ -172,7 +172,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryMembershipsForRoom", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryMembershipsForRoom", func(req *http.Request) util.JSONResponse {
var request api.QueryMembershipsForRoomRequest var request api.QueryMembershipsForRoomRequest
var response api.QueryMembershipsForRoomResponse var response api.QueryMembershipsForRoomResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryMembershipsForRoom(req.Context(), &request, &response); err != nil { if err := r.QueryMembershipsForRoom(req.Context(), &request, &response); err != nil {
@ -186,7 +186,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryServerJoinedToRoom", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryServerJoinedToRoom", func(req *http.Request) util.JSONResponse {
var request api.QueryServerJoinedToRoomRequest var request api.QueryServerJoinedToRoomRequest
var response api.QueryServerJoinedToRoomResponse var response api.QueryServerJoinedToRoomResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryServerJoinedToRoom(req.Context(), &request, &response); err != nil { if err := r.QueryServerJoinedToRoom(req.Context(), &request, &response); err != nil {
@ -200,7 +200,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryServerAllowedToSeeEvent", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryServerAllowedToSeeEvent", func(req *http.Request) util.JSONResponse {
var request api.QueryServerAllowedToSeeEventRequest var request api.QueryServerAllowedToSeeEventRequest
var response api.QueryServerAllowedToSeeEventResponse var response api.QueryServerAllowedToSeeEventResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryServerAllowedToSeeEvent(req.Context(), &request, &response); err != nil { if err := r.QueryServerAllowedToSeeEvent(req.Context(), &request, &response); err != nil {
@ -214,7 +214,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryMissingEvents", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryMissingEvents", func(req *http.Request) util.JSONResponse {
var request api.QueryMissingEventsRequest var request api.QueryMissingEventsRequest
var response api.QueryMissingEventsResponse var response api.QueryMissingEventsResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryMissingEvents(req.Context(), &request, &response); err != nil { if err := r.QueryMissingEvents(req.Context(), &request, &response); err != nil {
@ -228,7 +228,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryStateAndAuthChain", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryStateAndAuthChain", func(req *http.Request) util.JSONResponse {
var request api.QueryStateAndAuthChainRequest var request api.QueryStateAndAuthChainRequest
var response api.QueryStateAndAuthChainResponse var response api.QueryStateAndAuthChainResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryStateAndAuthChain(req.Context(), &request, &response); err != nil { if err := r.QueryStateAndAuthChain(req.Context(), &request, &response); err != nil {
@ -242,7 +242,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("PerformBackfill", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("PerformBackfill", func(req *http.Request) util.JSONResponse {
var request api.PerformBackfillRequest var request api.PerformBackfillRequest
var response api.PerformBackfillResponse var response api.PerformBackfillResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.PerformBackfill(req.Context(), &request, &response); err != nil { if err := r.PerformBackfill(req.Context(), &request, &response); err != nil {
@ -256,7 +256,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("QueryRoomVersionCapabilities", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("QueryRoomVersionCapabilities", func(req *http.Request) util.JSONResponse {
var request api.QueryRoomVersionCapabilitiesRequest var request api.QueryRoomVersionCapabilitiesRequest
var response api.QueryRoomVersionCapabilitiesResponse var response api.QueryRoomVersionCapabilitiesResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryRoomVersionCapabilities(req.Context(), &request, &response); err != nil { if err := r.QueryRoomVersionCapabilities(req.Context(), &request, &response); err != nil {
@ -270,7 +270,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("QueryRoomVersionForRoom", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("QueryRoomVersionForRoom", func(req *http.Request) util.JSONResponse {
var request api.QueryRoomVersionForRoomRequest var request api.QueryRoomVersionForRoomRequest
var response api.QueryRoomVersionForRoomResponse var response api.QueryRoomVersionForRoomResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.QueryRoomVersionForRoom(req.Context(), &request, &response); err != nil { if err := r.QueryRoomVersionForRoom(req.Context(), &request, &response); err != nil {
@ -284,7 +284,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("setRoomAlias", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("setRoomAlias", func(req *http.Request) util.JSONResponse {
var request api.SetRoomAliasRequest var request api.SetRoomAliasRequest
var response api.SetRoomAliasResponse var response api.SetRoomAliasResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.SetRoomAlias(req.Context(), &request, &response); err != nil { if err := r.SetRoomAlias(req.Context(), &request, &response); err != nil {
@ -298,7 +298,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("GetRoomIDForAlias", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("GetRoomIDForAlias", func(req *http.Request) util.JSONResponse {
var request api.GetRoomIDForAliasRequest var request api.GetRoomIDForAliasRequest
var response api.GetRoomIDForAliasResponse var response api.GetRoomIDForAliasResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.GetRoomIDForAlias(req.Context(), &request, &response); err != nil { if err := r.GetRoomIDForAlias(req.Context(), &request, &response); err != nil {
@ -312,7 +312,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("GetCreatorIDForAlias", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("GetCreatorIDForAlias", func(req *http.Request) util.JSONResponse {
var request api.GetCreatorIDForAliasRequest var request api.GetCreatorIDForAliasRequest
var response api.GetCreatorIDForAliasResponse var response api.GetCreatorIDForAliasResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.GetCreatorIDForAlias(req.Context(), &request, &response); err != nil { if err := r.GetCreatorIDForAlias(req.Context(), &request, &response); err != nil {
@ -326,7 +326,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("getAliasesForRoomID", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("getAliasesForRoomID", func(req *http.Request) util.JSONResponse {
var request api.GetAliasesForRoomIDRequest var request api.GetAliasesForRoomIDRequest
var response api.GetAliasesForRoomIDResponse var response api.GetAliasesForRoomIDResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.GetAliasesForRoomID(req.Context(), &request, &response); err != nil { if err := r.GetAliasesForRoomID(req.Context(), &request, &response); err != nil {
@ -340,7 +340,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("removeRoomAlias", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("removeRoomAlias", func(req *http.Request) util.JSONResponse {
var request api.RemoveRoomAliasRequest var request api.RemoveRoomAliasRequest
var response api.RemoveRoomAliasResponse var response api.RemoveRoomAliasResponse
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.ErrorResponse(err) return util.ErrorResponse(err)
} }
if err := r.RemoveRoomAlias(req.Context(), &request, &response); err != nil { if err := r.RemoveRoomAlias(req.Context(), &request, &response); err != nil {
@ -353,7 +353,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryCurrentState", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryCurrentState", func(req *http.Request) util.JSONResponse {
request := api.QueryCurrentStateRequest{} request := api.QueryCurrentStateRequest{}
response := api.QueryCurrentStateResponse{} response := api.QueryCurrentStateResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := r.QueryCurrentState(req.Context(), &request, &response); err != nil { if err := r.QueryCurrentState(req.Context(), &request, &response); err != nil {
@ -366,7 +366,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryRoomsForUser", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryRoomsForUser", func(req *http.Request) util.JSONResponse {
request := api.QueryRoomsForUserRequest{} request := api.QueryRoomsForUserRequest{}
response := api.QueryRoomsForUserResponse{} response := api.QueryRoomsForUserResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := r.QueryRoomsForUser(req.Context(), &request, &response); err != nil { if err := r.QueryRoomsForUser(req.Context(), &request, &response); err != nil {
@ -379,7 +379,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryBulkStateContent", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryBulkStateContent", func(req *http.Request) util.JSONResponse {
request := api.QueryBulkStateContentRequest{} request := api.QueryBulkStateContentRequest{}
response := api.QueryBulkStateContentResponse{} response := api.QueryBulkStateContentResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := r.QueryBulkStateContent(req.Context(), &request, &response); err != nil { if err := r.QueryBulkStateContent(req.Context(), &request, &response); err != nil {
@ -392,7 +392,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("querySharedUsers", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("querySharedUsers", func(req *http.Request) util.JSONResponse {
request := api.QuerySharedUsersRequest{} request := api.QuerySharedUsersRequest{}
response := api.QuerySharedUsersResponse{} response := api.QuerySharedUsersResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := r.QuerySharedUsers(req.Context(), &request, &response); err != nil { if err := r.QuerySharedUsers(req.Context(), &request, &response); err != nil {
@ -405,7 +405,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryKnownUsers", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryKnownUsers", func(req *http.Request) util.JSONResponse {
request := api.QueryKnownUsersRequest{} request := api.QueryKnownUsersRequest{}
response := api.QueryKnownUsersResponse{} response := api.QueryKnownUsersResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := r.QueryKnownUsers(req.Context(), &request, &response); err != nil { if err := r.QueryKnownUsers(req.Context(), &request, &response); err != nil {
@ -418,7 +418,7 @@ func AddRoutes(r api.RoomserverInternalAPI, internalAPIMux *mux.Router) {
httputil.MakeInternalAPI("queryServerBannedFromRoom", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryServerBannedFromRoom", func(req *http.Request) util.JSONResponse {
request := api.QueryServerBannedFromRoomRequest{} request := api.QueryServerBannedFromRoomRequest{}
response := api.QueryServerBannedFromRoomResponse{} response := api.QueryServerBannedFromRoomResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := r.QueryServerBannedFromRoom(req.Context(), &request, &response); err != nil { if err := r.QueryServerBannedFromRoom(req.Context(), &request, &response); err != nil {

6
roomserver/roomserver_test.go
View file

@ -4,7 +4,7 @@ import (
"bytes" "bytes"
"context" "context"
"crypto/ed25519" "crypto/ed25519"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"os" "os"
"reflect" "reflect"
@ -46,10 +46,10 @@ func (p *dummyProducer) SendMessage(msg *sarama.ProducerMessage) (partition int3
return 0, 0, nil return 0, 0, nil
} }
be := msg.Value.(sarama.ByteEncoder) be := msg.Value.(sarama.ByteEncoder)
b := json.RawMessage(be) b := jsoniter.RawMessage(be)
fmt.Println("SENDING >>>>>>>> ", string(b)) fmt.Println("SENDING >>>>>>>> ", string(b))
var out api.OutputEvent var out api.OutputEvent
err = json.Unmarshal(b, &out) err = jsoniter.Unmarshal(b, &out)
if err != nil { if err != nil {
return 0, 0, err return 0, 0, err
} }

4
roomserver/storage/shared/storage.go
View file

@ -3,7 +3,7 @@ package shared
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"sort" "sort"
@ -602,7 +602,7 @@ func extractRoomVersionFromCreateEvent(event gomatrixserverlib.Event) (
var createContent gomatrixserverlib.CreateContent var createContent gomatrixserverlib.CreateContent
// The m.room.create event contains an optional "room_version" key in // The m.room.create event contains an optional "room_version" key in
// the event content, so we need to unmarshal that first. // the event content, so we need to unmarshal that first.
if err = json.Unmarshal(event.Content(), &createContent); err != nil { if err = jsoniter.Unmarshal(event.Content(), &createContent); err != nil {
return gomatrixserverlib.RoomVersion(""), err return gomatrixserverlib.RoomVersion(""), err
} }
// A room version was specified in the event content? // A room version was specified in the event content?

4
roomserver/storage/sqlite3/events_table.go
View file

@ -18,7 +18,7 @@ package sqlite3
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"strings" "strings"
@ -488,6 +488,6 @@ func (s *eventStatements) SelectRoomNIDForEventNID(
} }
func eventNIDsAsArray(eventNIDs []types.EventNID) string { func eventNIDsAsArray(eventNIDs []types.EventNID) string {
b, _ := json.Marshal(eventNIDs) b, _ := jsoniter.Marshal(eventNIDs)
return string(b) return string(b)
} }

8
roomserver/storage/sqlite3/rooms_table.go
View file

@ -18,7 +18,7 @@ package sqlite3
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"errors" "errors"
"fmt" "fmt"
"strings" "strings"
@ -137,7 +137,7 @@ func (s *roomStatements) SelectRoomInfo(ctx context.Context, roomID string) (*ty
return nil, err return nil, err
} }
var latestNIDs []int64 var latestNIDs []int64
if err = json.Unmarshal([]byte(latestNIDsJSON), &latestNIDs); err != nil { if err = jsoniter.Unmarshal([]byte(latestNIDsJSON), &latestNIDs); err != nil {
return nil, err return nil, err
} }
info.IsStub = len(latestNIDs) == 0 info.IsStub = len(latestNIDs) == 0
@ -180,7 +180,7 @@ func (s *roomStatements) SelectLatestEventNIDs(
if err != nil { if err != nil {
return nil, 0, err return nil, 0, err
} }
if err := json.Unmarshal([]byte(nidsJSON), &eventNIDs); err != nil { if err := jsoniter.Unmarshal([]byte(nidsJSON), &eventNIDs); err != nil {
return nil, 0, err return nil, 0, err
} }
return eventNIDs, types.StateSnapshotNID(stateSnapshotNID), nil return eventNIDs, types.StateSnapshotNID(stateSnapshotNID), nil
@ -198,7 +198,7 @@ func (s *roomStatements) SelectLatestEventsNIDsForUpdate(
if err != nil { if err != nil {
return nil, 0, 0, err return nil, 0, 0, err
} }
if err := json.Unmarshal([]byte(nidsJSON), &eventNIDs); err != nil { if err := jsoniter.Unmarshal([]byte(nidsJSON), &eventNIDs); err != nil {
return nil, 0, 0, err return nil, 0, 0, err
} }
return eventNIDs, types.EventNID(lastEventSentNID), types.StateSnapshotNID(stateSnapshotNID), nil return eventNIDs, types.EventNID(lastEventSentNID), types.StateSnapshotNID(stateSnapshotNID), nil

6
roomserver/storage/sqlite3/state_snapshot_table.go
View file

@ -18,7 +18,7 @@ package sqlite3
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"strings" "strings"
@ -72,7 +72,7 @@ func NewSqliteStateSnapshotTable(db *sql.DB) (tables.StateSnapshot, error) {
func (s *stateSnapshotStatements) InsertState( func (s *stateSnapshotStatements) InsertState(
ctx context.Context, txn *sql.Tx, roomNID types.RoomNID, stateBlockNIDs []types.StateBlockNID, ctx context.Context, txn *sql.Tx, roomNID types.RoomNID, stateBlockNIDs []types.StateBlockNID,
) (stateNID types.StateSnapshotNID, err error) { ) (stateNID types.StateSnapshotNID, err error) {
stateBlockNIDsJSON, err := json.Marshal(stateBlockNIDs) stateBlockNIDsJSON, err := jsoniter.Marshal(stateBlockNIDs)
if err != nil { if err != nil {
return return
} }
@ -115,7 +115,7 @@ func (s *stateSnapshotStatements) BulkSelectStateBlockNIDs(
if err := rows.Scan(&result.StateSnapshotNID, &stateBlockNIDsJSON); err != nil { if err := rows.Scan(&result.StateSnapshotNID, &stateBlockNIDsJSON); err != nil {
return nil, err return nil, err
} }
if err := json.Unmarshal([]byte(stateBlockNIDsJSON), &result.StateBlockNIDs); err != nil { if err := jsoniter.Unmarshal([]byte(stateBlockNIDsJSON), &result.StateBlockNIDs); err != nil {
return nil, err return nil, err
} }
} }

6
signingkeyserver/inthttp/server.go
View file

@ -1,7 +1,7 @@
package inthttp package inthttp
import ( import (
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"github.com/gorilla/mux" "github.com/gorilla/mux"
@ -16,7 +16,7 @@ func AddRoutes(s api.SigningKeyServerAPI, internalAPIMux *mux.Router, cache cach
httputil.MakeInternalAPI("queryPublicKeys", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("queryPublicKeys", func(req *http.Request) util.JSONResponse {
request := api.QueryPublicKeysRequest{} request := api.QueryPublicKeysRequest{}
response := api.QueryPublicKeysResponse{} response := api.QueryPublicKeysResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
keys, err := s.FetchKeys(req.Context(), request.Requests) keys, err := s.FetchKeys(req.Context(), request.Requests)
@ -31,7 +31,7 @@ func AddRoutes(s api.SigningKeyServerAPI, internalAPIMux *mux.Router, cache cach
httputil.MakeInternalAPI("inputPublicKeys", func(req *http.Request) util.JSONResponse { httputil.MakeInternalAPI("inputPublicKeys", func(req *http.Request) util.JSONResponse {
request := api.InputPublicKeysRequest{} request := api.InputPublicKeysRequest{}
response := api.InputPublicKeysResponse{} response := api.InputPublicKeysResponse{}
if err := json.NewDecoder(req.Body).Decode(&request); err != nil { if err := jsoniter.NewDecoder(req.Body).Decode(&request); err != nil {
return util.MessageResponse(http.StatusBadRequest, err.Error()) return util.MessageResponse(http.StatusBadRequest, err.Error())
} }
if err := s.StoreKeys(req.Context(), request.Keys); err != nil { if err := s.StoreKeys(req.Context(), request.Keys); err != nil {

4
signingkeyserver/serverkeyapi_test.go
View file

@ -4,7 +4,7 @@ import (
"bytes" "bytes"
"context" "context"
"crypto/ed25519" "crypto/ed25519"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"net/http" "net/http"
@ -119,7 +119,7 @@ func (m *MockRoundTripper) RoundTrip(req *http.Request) (res *http.Response, err
// Get the keys and JSON-ify them. // Get the keys and JSON-ify them.
keys := routing.LocalKeys(s.fedconfig) keys := routing.LocalKeys(s.fedconfig)
body, err := json.MarshalIndent(keys.JSON, "", " ") body, err := jsoniter.MarshalIndent(keys.JSON, "", " ")
if err != nil { if err != nil {
return nil, err return nil, err
} }

4
syncapi/consumers/clientapi.go
View file

@ -16,7 +16,7 @@ package consumers
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
@ -70,7 +70,7 @@ func (s *OutputClientDataConsumer) Start() error {
func (s *OutputClientDataConsumer) onMessage(msg *sarama.ConsumerMessage) error { func (s *OutputClientDataConsumer) onMessage(msg *sarama.ConsumerMessage) error {
// Parse out the event JSON // Parse out the event JSON
var output eventutil.AccountData var output eventutil.AccountData
if err := json.Unmarshal(msg.Value, &output); err != nil { if err := jsoniter.Unmarshal(msg.Value, &output); err != nil {
// If the message was invalid, log it and move on to the next message in the stream // If the message was invalid, log it and move on to the next message in the stream
log.WithError(err).Errorf("client API server output log: message parse failure") log.WithError(err).Errorf("client API server output log: message parse failure")
return nil return nil

4
syncapi/consumers/eduserver_sendtodevice.go
View file

@ -16,7 +16,7 @@ package consumers
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
"github.com/matrix-org/dendrite/eduserver/api" "github.com/matrix-org/dendrite/eduserver/api"
@ -73,7 +73,7 @@ func (s *OutputSendToDeviceEventConsumer) Start() error {
func (s *OutputSendToDeviceEventConsumer) onMessage(msg *sarama.ConsumerMessage) error { func (s *OutputSendToDeviceEventConsumer) onMessage(msg *sarama.ConsumerMessage) error {
var output api.OutputSendToDeviceEvent var output api.OutputSendToDeviceEvent
if err := json.Unmarshal(msg.Value, &output); err != nil { if err := jsoniter.Unmarshal(msg.Value, &output); err != nil {
// If the message was invalid, log it and move on to the next message in the stream // If the message was invalid, log it and move on to the next message in the stream
log.WithError(err).Errorf("EDU server output log: message parse failure") log.WithError(err).Errorf("EDU server output log: message parse failure")
return err return err

4
syncapi/consumers/eduserver_typing.go
View file

@ -15,7 +15,7 @@
package consumers package consumers
import ( import (
"encoding/json" "github.com/json-iterator/go"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
"github.com/matrix-org/dendrite/eduserver/api" "github.com/matrix-org/dendrite/eduserver/api"
@ -75,7 +75,7 @@ func (s *OutputTypingEventConsumer) Start() error {
func (s *OutputTypingEventConsumer) onMessage(msg *sarama.ConsumerMessage) error { func (s *OutputTypingEventConsumer) onMessage(msg *sarama.ConsumerMessage) error {
var output api.OutputTypingEvent var output api.OutputTypingEvent
if err := json.Unmarshal(msg.Value, &output); err != nil { if err := jsoniter.Unmarshal(msg.Value, &output); err != nil {
// If the message was invalid, log it and move on to the next message in the stream // If the message was invalid, log it and move on to the next message in the stream
log.WithError(err).Errorf("EDU server output log: message parse failure") log.WithError(err).Errorf("EDU server output log: message parse failure")
return nil return nil

4
syncapi/consumers/keychange.go
View file

@ -16,7 +16,7 @@ package consumers
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"sync" "sync"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
@ -99,7 +99,7 @@ func (s *OutputKeyChangeEventConsumer) onMessage(msg *sarama.ConsumerMessage) er
defer s.updateOffset(msg) defer s.updateOffset(msg)
var output api.DeviceMessage var output api.DeviceMessage
if err := json.Unmarshal(msg.Value, &output); err != nil { if err := jsoniter.Unmarshal(msg.Value, &output); err != nil {
// If the message was invalid, log it and move on to the next message in the stream // If the message was invalid, log it and move on to the next message in the stream
log.WithError(err).Error("syncapi: failed to unmarshal key change event from key server") log.WithError(err).Error("syncapi: failed to unmarshal key change event from key server")
return err return err

4
syncapi/consumers/roomserver.go
View file

@ -16,7 +16,7 @@ package consumers
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"github.com/Shopify/sarama" "github.com/Shopify/sarama"
@ -78,7 +78,7 @@ func (s *OutputRoomEventConsumer) Start() error {
func (s *OutputRoomEventConsumer) onMessage(msg *sarama.ConsumerMessage) error { func (s *OutputRoomEventConsumer) onMessage(msg *sarama.ConsumerMessage) error {
// Parse out the event JSON // Parse out the event JSON
var output api.OutputEvent var output api.OutputEvent
if err := json.Unmarshal(msg.Value, &output); err != nil { if err := jsoniter.Unmarshal(msg.Value, &output); err != nil {
// If the message was invalid, log it and move on to the next message in the stream // If the message was invalid, log it and move on to the next message in the stream
log.WithError(err).Errorf("roomserver output log: message parse failure") log.WithError(err).Errorf("roomserver output log: message parse failure")
return nil return nil

4
syncapi/routing/filter.go
View file

@ -15,7 +15,7 @@
package routing package routing
import ( import (
"encoding/json" "github.com/json-iterator/go"
"io/ioutil" "io/ioutil"
"net/http" "net/http"
@ -93,7 +93,7 @@ func PutFilter(
} }
} }
if err = json.Unmarshal(body, &filter); err != nil { if err = jsoniter.Unmarshal(body, &filter); err != nil {
return util.JSONResponse{ return util.JSONResponse{
Code: http.StatusBadRequest, Code: http.StatusBadRequest,
JSON: jsonerror.BadJSON("The request body could not be decoded into valid JSON. " + err.Error()), JSON: jsonerror.BadJSON("The request body could not be decoded into valid JSON. " + err.Error()),

10
syncapi/storage/postgres/current_room_state_table.go
View file

@ -18,7 +18,7 @@ package postgres
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"github.com/lib/pq" "github.com/lib/pq"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
@ -236,12 +236,12 @@ func (s *currentRoomStateStatements) UpsertRoomState(
// Parse content as JSON and search for an "url" key // Parse content as JSON and search for an "url" key
containsURL := false containsURL := false
var content map[string]interface{} var content map[string]interface{}
if json.Unmarshal(event.Content(), &content) != nil { if jsoniter.Unmarshal(event.Content(), &content) != nil {
// Set containsURL to true if url is present // Set containsURL to true if url is present
_, containsURL = content["url"] _, containsURL = content["url"]
} }
headeredJSON, err := json.Marshal(event) headeredJSON, err := jsoniter.Marshal(event)
if err != nil { if err != nil {
return err return err
} }
@ -284,7 +284,7 @@ func rowsToEvents(rows *sql.Rows) ([]gomatrixserverlib.HeaderedEvent, error) {
} }
// TODO: Handle redacted events // TODO: Handle redacted events
var ev gomatrixserverlib.HeaderedEvent var ev gomatrixserverlib.HeaderedEvent
if err := json.Unmarshal(eventBytes, &ev); err != nil { if err := jsoniter.Unmarshal(eventBytes, &ev); err != nil {
return nil, err return nil, err
} }
result = append(result, ev) result = append(result, ev)
@ -305,7 +305,7 @@ func (s *currentRoomStateStatements) SelectStateEvent(
return nil, err return nil, err
} }
var ev gomatrixserverlib.HeaderedEvent var ev gomatrixserverlib.HeaderedEvent
if err = json.Unmarshal(res, &ev); err != nil { if err = jsoniter.Unmarshal(res, &ev); err != nil {
return nil, err return nil, err
} }
return &ev, err return &ev, err

6
syncapi/storage/postgres/filter_table.go
View file

@ -17,7 +17,7 @@ package postgres
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"github.com/matrix-org/dendrite/syncapi/storage/tables" "github.com/matrix-org/dendrite/syncapi/storage/tables"
"github.com/matrix-org/gomatrixserverlib" "github.com/matrix-org/gomatrixserverlib"
@ -84,7 +84,7 @@ func (s *filterStatements) SelectFilter(
// Unmarshal JSON into Filter struct // Unmarshal JSON into Filter struct
var filter gomatrixserverlib.Filter var filter gomatrixserverlib.Filter
if err = json.Unmarshal(filterData, &filter); err != nil { if err = jsoniter.Unmarshal(filterData, &filter); err != nil {
return nil, err return nil, err
} }
return &filter, nil return &filter, nil
@ -96,7 +96,7 @@ func (s *filterStatements) InsertFilter(
var existingFilterID string var existingFilterID string
// Serialise json // Serialise json
filterJSON, err := json.Marshal(filter) filterJSON, err := jsoniter.Marshal(filter)
if err != nil { if err != nil {
return "", err return "", err
} }

6
syncapi/storage/postgres/invites_table.go
View file

@ -18,7 +18,7 @@ package postgres
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
"github.com/matrix-org/dendrite/internal/sqlutil" "github.com/matrix-org/dendrite/internal/sqlutil"
@ -94,7 +94,7 @@ func (s *inviteEventsStatements) InsertInviteEvent(
ctx context.Context, txn *sql.Tx, inviteEvent gomatrixserverlib.HeaderedEvent, ctx context.Context, txn *sql.Tx, inviteEvent gomatrixserverlib.HeaderedEvent,
) (streamPos types.StreamPosition, err error) { ) (streamPos types.StreamPosition, err error) {
var headeredJSON []byte var headeredJSON []byte
headeredJSON, err = json.Marshal(inviteEvent) headeredJSON, err = jsoniter.Marshal(inviteEvent)
if err != nil { if err != nil {
return return
} }
@ -149,7 +149,7 @@ func (s *inviteEventsStatements) SelectInviteEventsInRange(
} }
var event gomatrixserverlib.HeaderedEvent var event gomatrixserverlib.HeaderedEvent
if err := json.Unmarshal(eventJSON, &event); err != nil { if err := jsoniter.Unmarshal(eventJSON, &event); err != nil {
return nil, nil, err return nil, nil, err
} }

12
syncapi/storage/postgres/output_room_events_table.go
View file

@ -18,7 +18,7 @@ package postgres
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"sort" "sort"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
@ -167,7 +167,7 @@ func NewPostgresEventsTable(db *sql.DB) (tables.Events, error) {
} }
func (s *outputRoomEventsStatements) UpdateEventJSON(ctx context.Context, event *gomatrixserverlib.HeaderedEvent) error { func (s *outputRoomEventsStatements) UpdateEventJSON(ctx context.Context, event *gomatrixserverlib.HeaderedEvent) error {
headeredJSON, err := json.Marshal(event) headeredJSON, err := jsoniter.Marshal(event)
if err != nil { if err != nil {
return err return err
} }
@ -231,7 +231,7 @@ func (s *outputRoomEventsStatements) SelectStateInRange(
// TODO: Handle redacted events // TODO: Handle redacted events
var ev gomatrixserverlib.HeaderedEvent var ev gomatrixserverlib.HeaderedEvent
if err := json.Unmarshal(eventBytes, &ev); err != nil { if err := jsoniter.Unmarshal(eventBytes, &ev); err != nil {
return nil, nil, err return nil, nil, err
} }
needSet := stateNeeded[ev.RoomID()] needSet := stateNeeded[ev.RoomID()]
@ -288,13 +288,13 @@ func (s *outputRoomEventsStatements) InsertEvent(
// Parse content as JSON and search for an "url" key // Parse content as JSON and search for an "url" key
containsURL := false containsURL := false
var content map[string]interface{} var content map[string]interface{}
if json.Unmarshal(event.Content(), &content) != nil { if jsoniter.Unmarshal(event.Content(), &content) != nil {
// Set containsURL to true if url is present // Set containsURL to true if url is present
_, containsURL = content["url"] _, containsURL = content["url"]
} }
var headeredJSON []byte var headeredJSON []byte
headeredJSON, err = json.Marshal(event) headeredJSON, err = jsoniter.Marshal(event)
if err != nil { if err != nil {
return return
} }
@ -425,7 +425,7 @@ func rowsToStreamEvents(rows *sql.Rows) ([]types.StreamEvent, error) {
} }
// TODO: Handle redacted events // TODO: Handle redacted events
var ev gomatrixserverlib.HeaderedEvent var ev gomatrixserverlib.HeaderedEvent
if err := json.Unmarshal(eventBytes, &ev); err != nil { if err := jsoniter.Unmarshal(eventBytes, &ev); err != nil {
return nil, err return nil, err
} }

4
syncapi/storage/postgres/send_to_device_table.go
View file

@ -17,7 +17,7 @@ package postgres
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"github.com/lib/pq" "github.com/lib/pq"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
@ -143,7 +143,7 @@ func (s *sendToDeviceStatements) SelectSendToDeviceMessages(
UserID: userID, UserID: userID,
DeviceID: deviceID, DeviceID: deviceID,
} }
if err = json.Unmarshal([]byte(content), &event.SendToDeviceEvent); err != nil { if err = jsoniter.Unmarshal([]byte(content), &event.SendToDeviceEvent); err != nil {
return return
} }
if sentByToken != nil { if sentByToken != nil {

6
syncapi/storage/shared/syncserver.go
View file

@ -17,7 +17,7 @@ package shared
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"time" "time"
@ -546,7 +546,7 @@ func (d *Database) addTypingDeltaToResponse(
ev := gomatrixserverlib.ClientEvent{ ev := gomatrixserverlib.ClientEvent{
Type: gomatrixserverlib.MTyping, Type: gomatrixserverlib.MTyping,
} }
ev.Content, err = json.Marshal(map[string]interface{}{ ev.Content, err = jsoniter.Marshal(map[string]interface{}{
"user_ids": typingUsers, "user_ids": typingUsers,
}) })
if err != nil { if err != nil {
@ -1280,7 +1280,7 @@ func (d *Database) SendToDeviceUpdatesWaiting(
func (d *Database) StoreNewSendForDeviceMessage( func (d *Database) StoreNewSendForDeviceMessage(
ctx context.Context, streamPos types.StreamPosition, userID, deviceID string, event gomatrixserverlib.SendToDeviceEvent, ctx context.Context, streamPos types.StreamPosition, userID, deviceID string, event gomatrixserverlib.SendToDeviceEvent,
) (types.StreamPosition, error) { ) (types.StreamPosition, error) {
j, err := json.Marshal(event) j, err := jsoniter.Marshal(event)
if err != nil { if err != nil {
return streamPos, err return streamPos, err
} }

10
syncapi/storage/sqlite3/current_room_state_table.go
View file

@ -18,7 +18,7 @@ package sqlite3
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"strings" "strings"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
@ -225,12 +225,12 @@ func (s *currentRoomStateStatements) UpsertRoomState(
// Parse content as JSON and search for an "url" key // Parse content as JSON and search for an "url" key
containsURL := false containsURL := false
var content map[string]interface{} var content map[string]interface{}
if json.Unmarshal(event.Content(), &content) != nil { if jsoniter.Unmarshal(event.Content(), &content) != nil {
// Set containsURL to true if url is present // Set containsURL to true if url is present
_, containsURL = content["url"] _, containsURL = content["url"]
} }
headeredJSON, err := json.Marshal(event) headeredJSON, err := jsoniter.Marshal(event)
if err != nil { if err != nil {
return err return err
} }
@ -295,7 +295,7 @@ func rowsToEvents(rows *sql.Rows) ([]gomatrixserverlib.HeaderedEvent, error) {
} }
// TODO: Handle redacted events // TODO: Handle redacted events
var ev gomatrixserverlib.HeaderedEvent var ev gomatrixserverlib.HeaderedEvent
if err := json.Unmarshal(eventBytes, &ev); err != nil { if err := jsoniter.Unmarshal(eventBytes, &ev); err != nil {
return nil, err return nil, err
} }
result = append(result, ev) result = append(result, ev)
@ -316,7 +316,7 @@ func (s *currentRoomStateStatements) SelectStateEvent(
return nil, err return nil, err
} }
var ev gomatrixserverlib.HeaderedEvent var ev gomatrixserverlib.HeaderedEvent
if err = json.Unmarshal(res, &ev); err != nil { if err = jsoniter.Unmarshal(res, &ev); err != nil {
return nil, err return nil, err
} }
return &ev, err return &ev, err

6
syncapi/storage/sqlite3/filter_table.go
View file

@ -17,7 +17,7 @@ package sqlite3
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"github.com/matrix-org/dendrite/syncapi/storage/tables" "github.com/matrix-org/dendrite/syncapi/storage/tables"
@ -88,7 +88,7 @@ func (s *filterStatements) SelectFilter(
// Unmarshal JSON into Filter struct // Unmarshal JSON into Filter struct
var filter gomatrixserverlib.Filter var filter gomatrixserverlib.Filter
if err = json.Unmarshal(filterData, &filter); err != nil { if err = jsoniter.Unmarshal(filterData, &filter); err != nil {
return nil, err return nil, err
} }
return &filter, nil return &filter, nil
@ -100,7 +100,7 @@ func (s *filterStatements) InsertFilter(
var existingFilterID string var existingFilterID string
// Serialise json // Serialise json
filterJSON, err := json.Marshal(filter) filterJSON, err := jsoniter.Marshal(filter)
if err != nil { if err != nil {
return "", err return "", err
} }

6
syncapi/storage/sqlite3/invites_table.go
View file

@ -18,7 +18,7 @@ package sqlite3
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
"github.com/matrix-org/dendrite/internal/sqlutil" "github.com/matrix-org/dendrite/internal/sqlutil"
@ -99,7 +99,7 @@ func (s *inviteEventsStatements) InsertInviteEvent(
} }
var headeredJSON []byte var headeredJSON []byte
headeredJSON, err = json.Marshal(inviteEvent) headeredJSON, err = jsoniter.Marshal(inviteEvent)
if err != nil { if err != nil {
return return
} }
@ -160,7 +160,7 @@ func (s *inviteEventsStatements) SelectInviteEventsInRange(
} }
var event gomatrixserverlib.HeaderedEvent var event gomatrixserverlib.HeaderedEvent
if err := json.Unmarshal(eventJSON, &event); err != nil { if err := jsoniter.Unmarshal(eventJSON, &event); err != nil {
return nil, nil, err return nil, nil, err
} }
if deleted { if deleted {

20
syncapi/storage/sqlite3/output_room_events_table.go
View file

@ -18,7 +18,7 @@ package sqlite3
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"sort" "sort"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
@ -160,7 +160,7 @@ func NewSqliteEventsTable(db *sql.DB, streamID *streamIDStatements) (tables.Even
} }
func (s *outputRoomEventsStatements) UpdateEventJSON(ctx context.Context, event *gomatrixserverlib.HeaderedEvent) error { func (s *outputRoomEventsStatements) UpdateEventJSON(ctx context.Context, event *gomatrixserverlib.HeaderedEvent) error {
headeredJSON, err := json.Marshal(event) headeredJSON, err := jsoniter.Marshal(event)
if err != nil { if err != nil {
return err return err
} }
@ -230,7 +230,7 @@ func (s *outputRoomEventsStatements) SelectStateInRange(
// TODO: Handle redacted events // TODO: Handle redacted events
var ev gomatrixserverlib.HeaderedEvent var ev gomatrixserverlib.HeaderedEvent
if err := json.Unmarshal(eventBytes, &ev); err != nil { if err := jsoniter.Unmarshal(eventBytes, &ev); err != nil {
return nil, nil, err return nil, nil, err
} }
needSet := stateNeeded[ev.RoomID()] needSet := stateNeeded[ev.RoomID()]
@ -287,22 +287,22 @@ func (s *outputRoomEventsStatements) InsertEvent(
// Parse content as JSON and search for an "url" key // Parse content as JSON and search for an "url" key
containsURL := false containsURL := false
var content map[string]interface{} var content map[string]interface{}
if json.Unmarshal(event.Content(), &content) != nil { if jsoniter.Unmarshal(event.Content(), &content) != nil {
// Set containsURL to true if url is present // Set containsURL to true if url is present
_, containsURL = content["url"] _, containsURL = content["url"]
} }
var headeredJSON []byte var headeredJSON []byte
headeredJSON, err := json.Marshal(event) headeredJSON, err := jsoniter.Marshal(event)
if err != nil { if err != nil {
return 0, err return 0, err
} }
addStateJSON, err := json.Marshal(addState) addStateJSON, err := jsoniter.Marshal(addState)
if err != nil { if err != nil {
return 0, err return 0, err
} }
removeStateJSON, err := json.Marshal(removeState) removeStateJSON, err := jsoniter.Marshal(removeState)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -440,7 +440,7 @@ func rowsToStreamEvents(rows *sql.Rows) ([]types.StreamEvent, error) {
} }
// TODO: Handle redacted events // TODO: Handle redacted events
var ev gomatrixserverlib.HeaderedEvent var ev gomatrixserverlib.HeaderedEvent
if err := json.Unmarshal(eventBytes, &ev); err != nil { if err := jsoniter.Unmarshal(eventBytes, &ev); err != nil {
return nil, err return nil, err
} }
@ -463,12 +463,12 @@ func rowsToStreamEvents(rows *sql.Rows) ([]types.StreamEvent, error) {
func unmarshalStateIDs(addIDsJSON, delIDsJSON string) (addIDs []string, delIDs []string, err error) { func unmarshalStateIDs(addIDsJSON, delIDsJSON string) (addIDs []string, delIDs []string, err error) {
if len(addIDsJSON) > 0 { if len(addIDsJSON) > 0 {
if err = json.Unmarshal([]byte(addIDsJSON), &addIDs); err != nil { if err = jsoniter.Unmarshal([]byte(addIDsJSON), &addIDs); err != nil {
return return
} }
} }
if len(delIDsJSON) > 0 { if len(delIDsJSON) > 0 {
if err = json.Unmarshal([]byte(delIDsJSON), &delIDs); err != nil { if err = jsoniter.Unmarshal([]byte(delIDsJSON), &delIDs); err != nil {
return return
} }
} }

4
syncapi/storage/sqlite3/send_to_device_table.go
View file

@ -17,7 +17,7 @@ package sqlite3
import ( import (
"context" "context"
"database/sql" "database/sql"
"encoding/json" "github.com/json-iterator/go"
"strings" "strings"
"github.com/matrix-org/dendrite/internal" "github.com/matrix-org/dendrite/internal"
@ -136,7 +136,7 @@ func (s *sendToDeviceStatements) SelectSendToDeviceMessages(
UserID: userID, UserID: userID,
DeviceID: deviceID, DeviceID: deviceID,
} }
if err = json.Unmarshal([]byte(content), &event.SendToDeviceEvent); err != nil { if err = jsoniter.Unmarshal([]byte(content), &event.SendToDeviceEvent); err != nil {
return return
} }
if sentByToken != nil { if sentByToken != nil {

4
syncapi/storage/storage_test.go
View file

@ -3,7 +3,7 @@ package storage_test
import ( import (
"context" "context"
"crypto/ed25519" "crypto/ed25519"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"os" "os"
"testing" "testing"
@ -550,7 +550,7 @@ func TestSendToDeviceBehaviour(t *testing.T) {
streamPos, err := db.StoreNewSendForDeviceMessage(ctx, types.StreamPosition(0), "alice", "one", gomatrixserverlib.SendToDeviceEvent{ streamPos, err := db.StoreNewSendForDeviceMessage(ctx, types.StreamPosition(0), "alice", "one", gomatrixserverlib.SendToDeviceEvent{
Sender: "bob", Sender: "bob",
Type: "m.type", Type: "m.type",
Content: json.RawMessage("{}"), Content: jsoniter.RawMessage("{}"),
}) })
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)

8
syncapi/sync/notifier_test.go
View file

@ -16,7 +16,7 @@ package sync
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"fmt" "fmt"
"sync" "sync"
"testing" "testing"
@ -49,7 +49,7 @@ var (
func init() { func init() {
var err error var err error
err = json.Unmarshal([]byte(`{ err = jsoniter.Unmarshal([]byte(`{
"_room_version": "1", "_room_version": "1",
"type": "m.room.message", "type": "m.room.message",
"content": { "content": {
@ -65,7 +65,7 @@ func init() {
if err != nil { if err != nil {
panic(err) panic(err)
} }
err = json.Unmarshal([]byte(`{ err = jsoniter.Unmarshal([]byte(`{
"_room_version": "1", "_room_version": "1",
"type": "m.room.member", "type": "m.room.member",
"state_key": "`+bob+`", "state_key": "`+bob+`",
@ -81,7 +81,7 @@ func init() {
if err != nil { if err != nil {
panic(err) panic(err)
} }
err = json.Unmarshal([]byte(`{ err = jsoniter.Unmarshal([]byte(`{
"_room_version": "1", "_room_version": "1",
"type": "m.room.member", "type": "m.room.member",
"state_key": "`+bob+`", "state_key": "`+bob+`",

4
syncapi/sync/request.go
View file

@ -16,7 +16,7 @@ package sync
import ( import (
"context" "context"
"encoding/json" "github.com/json-iterator/go"
"net/http" "net/http"
"strconv" "strconv"
"time" "time"
@ -75,7 +75,7 @@ func newSyncRequest(req *http.Request, device userapi.Device, syncDB storage.Dat
if filterQuery[0] == '{' { if filterQuery[0] == '{' {
// attempt to parse the timeline limit at least // attempt to parse the timeline limit at least
var f filter var f filter
err := json.Unmarshal([]byte(filterQuery), &f) err := jsoniter.Unmarshal([]byte(filterQuery), &f)
if err == nil && f.Room.Timeline.Limit != nil { if err == nil && f.Room.Timeline.Limit != nil {
timelineLimit = *f.Room.Timeline.Limit timelineLimit = *f.Room.Timeline.Limit
} }

12
syncapi/types/types.go
View file

@ -15,9 +15,9 @@
package types package types
import ( import (
"encoding/json"
"errors" "errors"
"fmt" "fmt"
"github.com/json-iterator/go"
"sort" "sort"
"strconv" "strconv"
"strings" "strings"
@ -372,7 +372,7 @@ func (p *syncToken) String() string {
// PrevEventRef represents a reference to a previous event in a state event upgrade // PrevEventRef represents a reference to a previous event in a state event upgrade
type PrevEventRef struct { type PrevEventRef struct {
PrevContent json.RawMessage `json:"prev_content"` PrevContent jsoniter.RawMessage `json:"prev_content"`
ReplacesState string `json:"replaces_state"` ReplacesState string `json:"replaces_state"`
PrevSender string `json:"prev_sender"` PrevSender string `json:"prev_sender"`
} }
@ -466,20 +466,20 @@ func NewJoinResponse() *JoinResponse {
// InviteResponse represents a /sync response for a room which is under the 'invite' key. // InviteResponse represents a /sync response for a room which is under the 'invite' key.
type InviteResponse struct { type InviteResponse struct {
InviteState struct { InviteState struct {
Events []json.RawMessage `json:"events"` Events []jsoniter.RawMessage `json:"events"`
} `json:"invite_state"` } `json:"invite_state"`
} }
// NewInviteResponse creates an empty response with initialised arrays. // NewInviteResponse creates an empty response with initialised arrays.
func NewInviteResponse(event gomatrixserverlib.HeaderedEvent) *InviteResponse { func NewInviteResponse(event gomatrixserverlib.HeaderedEvent) *InviteResponse {
res := InviteResponse{} res := InviteResponse{}
res.InviteState.Events = []json.RawMessage{} res.InviteState.Events = []jsoniter.RawMessage{}
// First see if there's invite_room_state in the unsigned key of the invite. // First see if there's invite_room_state in the unsigned key of the invite.
// If there is then unmarshal it into the response. This will contain the // If there is then unmarshal it into the response. This will contain the
// partial room state such as join rules, room name etc. // partial room state such as join rules, room name etc.
if inviteRoomState := gjson.GetBytes(event.Unsigned(), "invite_room_state"); inviteRoomState.Exists() { if inviteRoomState := gjson.GetBytes(event.Unsigned(), "invite_room_state"); inviteRoomState.Exists() {
_ = json.Unmarshal([]byte(inviteRoomState.Raw), &res.InviteState.Events) _ = jsoniter.Unmarshal([]byte(inviteRoomState.Raw), &res.InviteState.Events)
} }
// Then we'll see if we can create a partial of the invite event itself. // Then we'll see if we can create a partial of the invite event itself.
@ -487,7 +487,7 @@ func NewInviteResponse(event gomatrixserverlib.HeaderedEvent) *InviteResponse {
format, _ := event.RoomVersion.EventFormat() format, _ := event.RoomVersion.EventFormat()
inviteEvent := gomatrixserverlib.ToClientEvent(event.Unwrap(), format) inviteEvent := gomatrixserverlib.ToClientEvent(event.Unwrap(), format)
inviteEvent.Unsigned = nil inviteEvent.Unsigned = nil
if ev, err := json.Marshal(inviteEvent); err == nil { if ev, err := jsoniter.Marshal(inviteEvent); err == nil {
res.InviteState.Events = append(res.InviteState.Events, ev) res.InviteState.Events = append(res.InviteState.Events, ev)
} }

4
syncapi/types/types_test.go
View file

@ -1,7 +1,7 @@
package types package types
import ( import (
"encoding/json" "github.com/json-iterator/go"
"reflect" "reflect"
"testing" "testing"
@ -101,7 +101,7 @@ func TestNewInviteResponse(t *testing.T) {
} }
res := NewInviteResponse(ev.Headered(gomatrixserverlib.RoomVersionV5)) res := NewInviteResponse(ev.Headered(gomatrixserverlib.RoomVersionV5))
j, err := json.Marshal(res) j, err := jsoniter.Marshal(res)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }

Some files were not shown because too many files have changed in this diff Show more