gateway

type Codec interface {
	DecodeRequest(msgBytes []byte) (*Message, error)

	EncodeRequest(msg *Message) ([]byte, error)

	DecodeResponse(msgBytes []byte) (*Message, error)

	EncodeResponse(msg *Message) ([]byte, error)

	EncodeNewErrorResponse(id string, code int, message string, data []byte) ([]byte, error)
}

type ConnectionManager interface {
	job.ServiceCtx
	network.ConnectionAcceptor

	DONConnectionManager(donId string) DONConnectionManager
}

type ConnectionManagerConfig struct {
	AuthTimestampToleranceSec uint32
	AuthChallengeLen          uint32
}

type DONConfig struct {
	DonId         string
	HandlerName   string
	HandlerConfig json.RawMessage
	Members       []NodeConfig
}

type DONConnectionManager interface {
	SetHandler(handler Handler)

	// Thread-safe.
	SendToNode(ctx context.Context, nodeAddress string, msg *Message) error
}

type Delegate struct {
	// contains filtered or unexported fields
}

type ErrorCode int

type Gateway interface {
	job.ServiceCtx
	gw_net.HTTPRequestHandler
}

type GatewayConfig struct {
	UserServerConfig        gw_net.HTTPServerConfig
	NodeServerConfig        gw_net.WebSocketServerConfig
	ConnectionManagerConfig ConnectionManagerConfig
	Dons                    []DONConfig
}

type Handler interface {
	job.ServiceCtx

	// Each user request is processed by a separate goroutine, which:
	//   1. calls HandleUserMessage
	//   2. waits on callbackCh with a timeout
	HandleUserMessage(ctx context.Context, msg *Message, callbackCh chan<- UserCallbackPayload) error

	// Handlers should not make any assumptions about goroutines calling HandleNodeMessage
	HandleNodeMessage(ctx context.Context, msg *Message, nodeAddr string) error
}

type HandlerType = string

type JsonRPCCodec struct {
}

type JsonRPCError struct {
	Code    int             `json:"code"`
	Message string          `json:"message"`
	Data    json.RawMessage `json:"data,omitempty"`
}

type JsonRPCRequest struct {
	Version string   `json:"jsonrpc"`
	Id      string   `json:"id"`
	Method  string   `json:"method"`
	Params  *Message `json:"params,omitempty"`
}

type JsonRPCResponse struct {
	Version string        `json:"jsonrpc"`
	Id      string        `json:"id"`
	Result  *Message      `json:"result,omitempty"`
	Error   *JsonRPCError `json:"error,omitempty"`
}

type Message struct {
	Signature string      `json:"signature"`
	Body      MessageBody `json:"body"`
}

type MessageBody struct {
	MessageId string `json:"message_id"`
	Method    string `json:"method"`
	DonId     string `json:"don_id"`
	Sender    string `json:"sender"`

	// Service-specific payload, decoded inside the Handler.
	Payload json.RawMessage `json:"payload,omitempty"`
}

type NodeConfig struct {
	Name    string
	Address string
}

type UserCallbackPayload struct {
	Msg     *Message
	ErrCode ErrorCode
	ErrMsg  string
}