code.vegaprotocol.io/vega@v0.79.0/datanode/gateway/rest/server.go

// Copyright (C) 2023 Gobalsky Labs Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package rest

import (
	"context"
	"net"
	"net/http"
	"strconv"
	"strings"

	"code.vegaprotocol.io/vega/datanode/gateway"
	"code.vegaprotocol.io/vega/logging"
	"code.vegaprotocol.io/vega/paths"
	protoapiv2 "code.vegaprotocol.io/vega/protos/data-node/api/v2"
	vegaprotoapi "code.vegaprotocol.io/vega/protos/vega/api/v1"

	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
	"github.com/tmc/grpc-websocket-proxy/wsproxy"
	"go.elastic.co/apm/module/apmhttp"
	"google.golang.org/grpc"
	"google.golang.org/protobuf/encoding/protojson"
)

const (
	namedLogger = "restproxy"
)

// ProxyServer implement a rest server acting as a proxy to the grpc api.
type ProxyServer struct {
	gateway.Config
	log       *logging.Logger
	vegaPaths paths.Paths
	srv       *http.Server
}

// NewProxyServer returns a new instance of the rest proxy server.
func NewProxyServer(log *logging.Logger, config gateway.Config, vegaPaths paths.Paths) *ProxyServer {
	// setup logger
	log = log.Named(namedLogger)
	log.SetLevel(config.Level.Get())

	return &ProxyServer{
		log:       log,
		Config:    config,
		srv:       nil,
		vegaPaths: vegaPaths,
	}
}

// ReloadConf update the internal configuration of the server.
func (s *ProxyServer) ReloadConf(cfg gateway.Config) {
	s.log.Info("reloading configuration")
	if s.log.GetLevel() != cfg.Level.Get() {
		s.log.Info("updating log level",
			logging.String("old", s.log.GetLevel().String()),
			logging.String("new", cfg.Level.String()),
		)
		s.log.SetLevel(cfg.Level.Get())
	}

	// TODO(): not updating the the actual server for now, may need to look at this later
	// e.g restart the http server on another port or whatever
	s.Config = cfg
}

// This is because by default the marshaller wants to put a newline between chunks of the stream response.
type HTTPBodyDelimitedMarshaler struct {
	runtime.HTTPBodyMarshaler

	delimiter []byte
}

func (o *HTTPBodyDelimitedMarshaler) Delimiter() []byte {
	return o.delimiter
}

// Start start the server.
func (s *ProxyServer) Start(ctx context.Context) (http.Handler, error) {
	logger := s.log

	grpcAddr := net.JoinHostPort(s.Node.IP, strconv.Itoa(s.Node.Port))

	mux := runtime.NewServeMux(
		// this is a settings specially made for websockets
		runtime.WithMarshalerOption("application/json+stream", &JSONPb{
			EnumsAsInts:  true,
			EmitDefaults: false,
			OrigName:     false,
		}),
		// prettified, just for JonRay
		// append ?pretty to any query to make it... pretty
		runtime.WithMarshalerOption("application/json+pretty", &JSONPb{
			EnumsAsInts:  false,
			EmitDefaults: true,
			OrigName:     false,
			Indent:       " ",
		}),
		runtime.WithMarshalerOption("text/csv", &HTTPBodyDelimitedMarshaler{
			delimiter: []byte(""), // Don't append newline between stream sends
			// Default HTTPBodyMarshaler
			HTTPBodyMarshaler: runtime.HTTPBodyMarshaler{
				Marshaler: &runtime.JSONPb{
					MarshalOptions: protojson.MarshalOptions{
						EmitUnpopulated: true,
					},
					UnmarshalOptions: protojson.UnmarshalOptions{
						DiscardUnknown: true,
					},
				},
			},
		}),
		// default for REST request
		runtime.WithMarshalerOption(runtime.MIMEWildcard, &JSONPb{
			EmitDefaults: true,
			OrigName:     false,
		}),

		runtime.WithOutgoingHeaderMatcher(func(s string) (string, bool) { return s, true }),
	)

	opts := []grpc.DialOption{
		grpc.WithInsecure(),
		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(s.Config.Node.MaxMsgSize)),
	}

	marshalW := func(h http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			// if we are dealing with a stream, let's add some header to use the proper marshaller
			if strings.HasPrefix(r.URL.Path, "/api/v2/stream/") {
				r.Header.Set("Accept", "application/json+stream")
			} else if strings.HasPrefix(r.URL.Path, "/api/v2/networkhistory/export") ||
				strings.HasPrefix(r.URL.Path, "/api/v2/ledgerentry/export") {
				r.Header.Set("Accept", "text/csv")
			} else if _, ok := r.URL.Query()["pretty"]; ok {
				// checking Values as map[string][]string also catches ?pretty and ?pretty=
				// r.URL.Query().Get("pretty") would not.
				r.Header.Set("Accept", "application/json+pretty")
			}
			h.ServeHTTP(w, r)
		})
	}

	if err := vegaprotoapi.RegisterCoreServiceHandlerFromEndpoint(ctx, mux, grpcAddr, opts); err != nil {
		logger.Panic("Failure registering trading handler for REST proxy endpoints", logging.Error(err))
	}
	if err := protoapiv2.RegisterTradingDataServiceHandlerFromEndpoint(ctx, mux, grpcAddr, opts); err != nil {
		logger.Panic("Failure registering trading handler for REST proxy endpoints", logging.Error(err))
	}

	handler := marshalW(mux)
	handler = healthCheckMiddleware(handler)
	handler = gateway.RemoteAddrMiddleware(logger, handler)
	// Gzip encoding support
	handler = NewGzipHandler(*logger, handler.(http.HandlerFunc))
	// Metric support
	handler = gateway.MetricCollectionMiddleware(handler)
	handler = wsproxy.WebsocketProxy(handler)

	// APM
	if s.REST.APMEnabled {
		handler = apmhttp.Wrap(handler)
	}

	return handler, nil
}

func healthCheckMiddleware(f http.Handler) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path == "/health" {
			_, _ = w.Write([]byte("ok"))
			w.WriteHeader(http.StatusOK)
			return
		}
		f.ServeHTTP(w, r)
	}
}