242 lines
8.4 KiB
Go
242 lines
8.4 KiB
Go
package control
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
|
|
rvboxv1 "github.com/rvbox/rvbox/gen/go/rvbox/v1"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/encoding/protojson"
|
|
"google.golang.org/protobuf/proto"
|
|
)
|
|
|
|
const (
|
|
jsonRPCVersion = "2.0"
|
|
jsonRPCParseError = -32700
|
|
jsonRPCInvalid = -32600
|
|
jsonRPCMethodAbsent = -32601
|
|
jsonRPCServerError = -32000
|
|
defaultJSONRPCBody = 24 << 20
|
|
)
|
|
|
|
// JSONRPCHandler adapts unary Control methods to standard JSON-RPC 2.0. It
|
|
// intentionally has no authentication in v1; callers should keep it loopback
|
|
// bound unless they explicitly accept the debugging exposure.
|
|
type JSONRPCHandler struct {
|
|
Service *Service
|
|
MaxBody int64
|
|
Decoder protojson.UnmarshalOptions
|
|
Encoder protojson.MarshalOptions
|
|
}
|
|
|
|
func NewJSONRPCHandler(service *Service, maxBody int64) *JSONRPCHandler {
|
|
if maxBody <= 0 {
|
|
maxBody = defaultJSONRPCBody
|
|
}
|
|
return &JSONRPCHandler{Service: service, MaxBody: maxBody, Decoder: protojson.UnmarshalOptions{DiscardUnknown: false}, Encoder: protojson.MarshalOptions{UseProtoNames: false}}
|
|
}
|
|
|
|
func (handler *JSONRPCHandler) ServeHTTP(response http.ResponseWriter, request *http.Request) {
|
|
if request.Method != http.MethodPost {
|
|
response.Header().Set("Allow", http.MethodPost)
|
|
http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
if handler == nil || handler.Service == nil {
|
|
http.Error(response, "control service unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
body, err := io.ReadAll(io.LimitReader(request.Body, handler.MaxBody+1))
|
|
if err != nil {
|
|
handler.writeRPCError(response, nil, jsonRPCParseError, "could not read request", nil)
|
|
return
|
|
}
|
|
if int64(len(body)) > handler.MaxBody {
|
|
handler.writeRPCError(response, nil, jsonRPCInvalid, "request body exceeds limit", nil)
|
|
return
|
|
}
|
|
var envelope jsonRPCRequest
|
|
decoder := json.NewDecoder(bytes.NewReader(body))
|
|
decoder.DisallowUnknownFields()
|
|
if err := decoder.Decode(&envelope); err != nil {
|
|
handler.writeRPCError(response, nil, jsonRPCParseError, "invalid JSON", nil)
|
|
return
|
|
}
|
|
var trailing any
|
|
if err := decoder.Decode(&trailing); err != io.EOF || envelope.JSONRPC != jsonRPCVersion || envelope.Method == "" || len(envelope.ID) == 0 || bytes.Equal(bytes.TrimSpace(envelope.ID), []byte("null")) {
|
|
handler.writeRPCError(response, nil, jsonRPCInvalid, "invalid JSON-RPC request", nil)
|
|
return
|
|
}
|
|
result, callErr := handler.call(request.Context(), envelope.Method, envelope.Params)
|
|
if callErr != nil {
|
|
code, message, data := jsonRPCDomainError(callErr)
|
|
handler.writeRPCError(response, envelope.ID, code, message, data)
|
|
return
|
|
}
|
|
handler.writeRPCResult(response, envelope.ID, result)
|
|
}
|
|
|
|
type jsonRPCRequest struct {
|
|
JSONRPC string `json:"jsonrpc"`
|
|
ID json.RawMessage `json:"id"`
|
|
Method string `json:"method"`
|
|
Params json.RawMessage `json:"params"`
|
|
}
|
|
|
|
type jsonRPCResponse struct {
|
|
JSONRPC string `json:"jsonrpc"`
|
|
ID json.RawMessage `json:"id"`
|
|
Result json.RawMessage `json:"result,omitempty"`
|
|
Error *jsonRPCError `json:"error,omitempty"`
|
|
}
|
|
|
|
type jsonRPCError struct {
|
|
Code int `json:"code"`
|
|
Message string `json:"message"`
|
|
Data json.RawMessage `json:"data,omitempty"`
|
|
}
|
|
|
|
func (handler *JSONRPCHandler) call(ctx context.Context, method string, params json.RawMessage) (proto.Message, error) {
|
|
decode := func(message proto.Message) error {
|
|
if len(params) == 0 || bytes.Equal(bytes.TrimSpace(params), []byte("null")) {
|
|
params = []byte("{}")
|
|
}
|
|
return handler.Decoder.Unmarshal(params, message)
|
|
}
|
|
switch method {
|
|
case "listClients":
|
|
input := &rvboxv1.ListClientsRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.ListClients(ctx, input)
|
|
case "getClient":
|
|
input := &rvboxv1.GetClientRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.GetClient(ctx, input)
|
|
case "listCommands":
|
|
input := &rvboxv1.ListCommandsRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.ListCommands(ctx, input)
|
|
case "getCommand":
|
|
input := &rvboxv1.GetCommandRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.GetCommand(ctx, input)
|
|
case "runCommand":
|
|
input := &rvboxv1.RunCommandRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.RunCommand(ctx, input)
|
|
case "appendStdin":
|
|
input := &rvboxv1.AppendStdinRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.AppendStdin(ctx, input)
|
|
case "closeStdin":
|
|
input := &rvboxv1.CloseStdinRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.CloseStdin(ctx, input)
|
|
case "signalCommand":
|
|
input := &rvboxv1.ControlSignalCommandRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.SignalCommand(ctx, input)
|
|
case "getOutput":
|
|
input := &rvboxv1.GetOutputRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.GetOutput(ctx, input)
|
|
case "listStorageIncidents":
|
|
input := &rvboxv1.ListStorageIncidentsRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.ListStorageIncidents(ctx, input)
|
|
case "repairStorageIncident":
|
|
input := &rvboxv1.RepairStorageIncidentRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.RepairStorageIncident(ctx, input)
|
|
case "acknowledgeStorageIncident":
|
|
input := &rvboxv1.AcknowledgeStorageIncidentRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.AcknowledgeStorageIncident(ctx, input)
|
|
case "authorizeClientTakeover":
|
|
input := &rvboxv1.AuthorizeClientTakeoverRequest{}
|
|
if err := decode(input); err != nil {
|
|
return nil, status.Error(codes.InvalidArgument, err.Error())
|
|
}
|
|
return handler.Service.AuthorizeClientTakeover(ctx, input)
|
|
default:
|
|
return nil, status.Error(codes.Unimplemented, "method not found")
|
|
}
|
|
}
|
|
|
|
func (handler *JSONRPCHandler) writeRPCResult(response http.ResponseWriter, id json.RawMessage, message proto.Message) {
|
|
encoded, err := handler.Encoder.Marshal(message)
|
|
if err != nil {
|
|
handler.writeRPCError(response, id, jsonRPCServerError, "could not encode response", nil)
|
|
return
|
|
}
|
|
response.Header().Set("Content-Type", "application/json")
|
|
response.WriteHeader(http.StatusOK)
|
|
_, _ = response.Write(mustJSON(jsonRPCResponse{JSONRPC: jsonRPCVersion, ID: append([]byte(nil), id...), Result: encoded}))
|
|
}
|
|
|
|
func (handler *JSONRPCHandler) writeRPCError(response http.ResponseWriter, id json.RawMessage, code int, message string, data json.RawMessage) {
|
|
if len(id) == 0 {
|
|
id = []byte("null")
|
|
}
|
|
response.Header().Set("Content-Type", "application/json")
|
|
response.WriteHeader(http.StatusOK)
|
|
_, _ = response.Write(mustJSON(jsonRPCResponse{JSONRPC: jsonRPCVersion, ID: append([]byte(nil), id...), Error: &jsonRPCError{Code: code, Message: message, Data: data}}))
|
|
}
|
|
|
|
func jsonRPCDomainError(err error) (int, string, json.RawMessage) {
|
|
if err == nil {
|
|
return 0, "", nil
|
|
}
|
|
converted := status.Convert(err)
|
|
if converted.Code() == codes.Unimplemented && converted.Message() == "method not found" {
|
|
return jsonRPCMethodAbsent, converted.Message(), nil
|
|
}
|
|
data := []byte(nil)
|
|
for _, detail := range converted.Details() {
|
|
if control, ok := detail.(*rvboxv1.ControlError); ok {
|
|
data, _ = protojson.Marshal(control)
|
|
break
|
|
}
|
|
}
|
|
if converted.Code() == codes.InvalidArgument {
|
|
return jsonRPCInvalid, converted.Message(), data
|
|
}
|
|
return jsonRPCServerError, converted.Message(), data
|
|
}
|
|
|
|
func mustJSON(value any) []byte {
|
|
encoded, err := json.Marshal(value)
|
|
if err != nil {
|
|
return []byte(`{"jsonrpc":"2.0","id":null,"error":{"code":-32000,"message":"internal encoding error"}}`)
|
|
}
|
|
return encoded
|
|
}
|