Method handle

pkg/interop/server.go:183–279

()

}

func (s *Server) handle() http.Handler {
	senderAuthenticators := map[MessageType]senderAuthenticator{
		MessageTypeJoinReq:    senderAuthenticatorFunc(s.authenticateNS),
		MessageTypeRejoinReq:  senderAuthenticatorFunc(s.authenticateNS),
		MessageTypeAppSKeyReq: senderAuthenticatorFunc(s.authenticateAS),
		MessageTypeHomeNSReq:  senderAuthenticatorFunc(s.authenticateNS),
	}

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		cid := fmt.Sprintf("interop:%s", r.Header.Get("X-Request-ID"))
		ctx := events.ContextWithCorrelationID(r.Context(), cid)
		logger := log.FromContext(ctx)

		data, err := io.ReadAll(r.Body)
		if err != nil {
			logger.WithError(err).Debug("Failed to read body")
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		var header MessageHeader
		if err := json.Unmarshal(data, &header); err != nil {
			logger.WithError(err).Debug("Failed to unmarshal body")
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		logger = logger.WithFields(log.Fields(
			"message_type", header.MessageType,
			"protocol_version", header.ProtocolVersion,
			"sender_id", header.SenderID,
			"receiver_id", header.ReceiverID,
		))
		ctx = log.NewContext(ctx, logger)

		if err := header.MessageType.Validate(header.ProtocolVersion); err != nil {
			logger.WithError(err).Debug("Invalid protocol version or message type")
			writeError(w, r, header, err)
			return
		}

		senderAuthenticator, ok := senderAuthenticators[header.MessageType]
		if !ok {
			writeError(w, r, header, ErrMalformedMessage.New())
			return
		}
		ctx, err = senderAuthenticator.Authenticate(ctx, r, data)
		if err != nil {
			logRPCError(logger, err, "Failed to authenticate")
			writeError(w, r, header, err)
			return
		}

		var msg any
		switch header.MessageType {
		case MessageTypeJoinReq, MessageTypeRejoinReq:
			msg = &JoinReq{}
		case MessageTypeAppSKeyReq: