Merge remote-tracking branch 'origin/rc/v1.7.0' into SF-v1.7.0

README.md

@@ -83,6 +83,36 @@ sudo cp protoc-gen-gogoslick /usr/bin/
 
 Done
 
+## Running p2p Prometheus dashboards
+1. Start the node with `--p2p-prometheus-metrics` flag. This exposes a metrics collection at http://localhost:8080/debug/metrics/prometheus (port defined by -rest-api-interface flag, default 8080)
+2. Clone libp2p repository: `git clone https://github.com/libp2p/go-libp2p`
+3. `cd go-libp2p/dasboards/swarm` and under the 
+```  
+"templating": {
+   "list": [
+```
+section, add the following lines:
+```
+{
+  "hide": 0,
+  "label": "datasource",
+  "name": "DS_PROMETHEUS",
+  "options": [],
+  "query": "prometheus",
+  "refresh": 1,
+  "regex": "",
+  "type": "datasource"
+},
+```
+(this step will be removed once it will be fixed on libp2p)
+4. `cd ..` to dashboards directory and update the port of `host.docker.internal` from `prometheus.yml` to node's Rest API port(default `8080`)
+5. From this directory, run the following docker compose command: 
+```
+sudo docker compose -f docker-compose.base.yml -f docker-compose-linux.yml up --force-recreate
+```
+**Note:** If you choose to install the new Docker version manually, please make sure that installation is done for all users of the system. Otherwise, the docker command will fail because it needs the super-user privileges.
+6. The preconfigured dashboards should be now available on Grafana at http://localhost:3000/dashboards
+
 ## Progress
 
 ### Done

api/errors/errors.go

@@ -171,3 +171,6 @@ var ErrGetEligibleManagedKeys = errors.New("error getting the eligible managed k
 
 // ErrGetWaitingManagedKeys signals that an error occurred while getting the waiting managed keys
 var ErrGetWaitingManagedKeys = errors.New("error getting the waiting managed keys")
+
+// ErrGetWaitingEpochsLeftForPublicKey signals that an error occurred while getting the waiting epochs left for public key
+var ErrGetWaitingEpochsLeftForPublicKey = errors.New("error getting the waiting epochs left for public key")

api/gin/common_test.go

@@ -22,7 +22,12 @@ func TestCommon_checkArgs(t *testing.T) {
 	err := checkArgs(args)
 	require.True(t, errors.Is(err, apiErrors.ErrCannotCreateGinWebServer))
 
-	args.Facade, err = initial.NewInitialNodeFacade("api interface", false, &testscommon.StatusMetricsStub{})
+	args.Facade, err = initial.NewInitialNodeFacade(initial.ArgInitialNodeFacade{
+		ApiInterface:                "api interface",
+		PprofEnabled:                false,
+		P2PPrometheusMetricsEnabled: false,
+		StatusMetricsHandler:        &testscommon.StatusMetricsStub{},
+	})
 	require.NoError(t, err)
 	err = checkArgs(args)
 	require.NoError(t, err)

api/gin/webServer.go

@@ -19,10 +19,13 @@ import (
 	"github.com/multiversx/mx-chain-go/config"
 	"github.com/multiversx/mx-chain-go/facade"
 	logger "github.com/multiversx/mx-chain-logger-go"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
 )
 
 var log = logger.GetOrCreate("api/gin")
 
+const prometheusMetricsRoute = "/debug/metrics/prometheus"
+
 // ArgsNewWebServer holds the arguments needed to create a new instance of webServer
 type ArgsNewWebServer struct {
 	Facade          shared.FacadeHandler
@@ -227,6 +230,10 @@ func (ws *webServer) registerRoutes(ginRouter *gin.Engine) {
 	if ws.facade.PprofEnabled() {
 		pprof.Register(ginRouter)
 	}
+
+	if ws.facade.P2PPrometheusMetricsEnabled() {
+		ginRouter.GET(prometheusMetricsRoute, gin.WrapH(promhttp.Handler()))
+	}
 }
 
 func (ws *webServer) createMiddlewareLimiters() ([]shared.MiddlewareProcessor, error) {

api/groups/nodeGroup.go

@@ -31,6 +31,7 @@ const (
 	managedKeysCount          = "/managed-keys/count"
 	eligibleManagedKeys       = "/managed-keys/eligible"
 	waitingManagedKeys        = "/managed-keys/waiting"
+	epochsLeftInWaiting       = "/waiting-epochs-left/:key"
 )
 
 // nodeFacadeHandler defines the methods to be implemented by a facade for node requests
@@ -45,6 +46,7 @@ type nodeFacadeHandler interface {
 	GetManagedKeys() []string
 	GetEligibleManagedKeys() ([]string, error)
 	GetWaitingManagedKeys() ([]string, error)
+	GetWaitingEpochsLeftForPublicKey(publicKey string) (uint32, error)
 	IsInterfaceNil() bool
 }
 
@@ -137,6 +139,11 @@ func NewNodeGroup(facade nodeFacadeHandler) (*nodeGroup, error) {
 			Method:  http.MethodGet,
 			Handler: ng.managedKeysWaiting,
 		},
+		{
+			Path:    epochsLeftInWaiting,
+			Method:  http.MethodGet,
+			Handler: ng.waitingEpochsLeft,
+		},
 	}
 	ng.endpoints = endpoints
 
@@ -440,6 +447,18 @@ func (ng *nodeGroup) managedKeysWaiting(c *gin.Context) {
 	)
 }
 
+// waitingEpochsLeft returns the number of epochs left for the public key until it becomes eligible
+func (ng *nodeGroup) waitingEpochsLeft(c *gin.Context) {
+	publicKey := c.Param("key")
+	epochsLeft, err := ng.getFacade().GetWaitingEpochsLeftForPublicKey(publicKey)
+	if err != nil {
+		shared.RespondWithInternalError(c, errors.ErrGetWaitingEpochsLeftForPublicKey, err)
+		return
+	}
+
+	shared.RespondWithSuccess(c, gin.H{"epochsLeft": epochsLeft})
+}
+
 func (ng *nodeGroup) getFacade() nodeFacadeHandler {
 	ng.mutFacade.RLock()
 	defer ng.mutFacade.RUnlock()

api/groups/nodeGroup_test.go

@@ -95,6 +95,13 @@ type managedWaitingKeysResponse struct {
 	generalResponse
 }
 
+type waitingEpochsLeftResponse struct {
+	Data struct {
+		EpochsLeft uint32 `json:"epochsLeft"`
+	} `json:"data"`
+	generalResponse
+}
+
 func init() {
 	gin.SetMode(gin.TestMode)
 }
@@ -276,6 +283,30 @@ func TestBootstrapStatusMetrics_ShouldWork(t *testing.T) {
 func TestNodeGroup_GetConnectedPeersRatings(t *testing.T) {
 	t.Parallel()
 
+	t.Run("facade error should error", func(t *testing.T) {
+		t.Parallel()
+
+		facade := mock.FacadeStub{
+			GetConnectedPeersRatingsOnMainNetworkCalled: func() (string, error) {
+				return "", expectedErr
+			},
+		}
+
+		nodeGroup, err := groups.NewNodeGroup(&facade)
+		require.NoError(t, err)
+
+		ws := startWebServer(nodeGroup, "node", getNodeRoutesConfig())
+
+		req, _ := http.NewRequest("GET", "/node/connected-peers-ratings", nil)
+		resp := httptest.NewRecorder()
+		ws.ServeHTTP(resp, req)
+
+		response := &shared.GenericAPIResponse{}
+		loadResponse(resp.Body, response)
+
+		assert.Equal(t, http.StatusInternalServerError, resp.Code)
+		assert.True(t, strings.Contains(response.Error, expectedErr.Error()))
+	})
 	t.Run("should work", func(t *testing.T) {
 		t.Parallel()
 
@@ -851,6 +882,61 @@ func TestNodeGroup_ManagedKeysWaiting(t *testing.T) {
 	})
 }
 
+func TestNodeGroup_WaitingEpochsLeft(t *testing.T) {
+	t.Parallel()
+
+	t.Run("facade error should error", func(t *testing.T) {
+		t.Parallel()
+
+		facade := mock.FacadeStub{
+			GetWaitingEpochsLeftForPublicKeyCalled: func(publicKey string) (uint32, error) {
+				return 0, expectedErr
+			},
+		}
+
+		nodeGroup, err := groups.NewNodeGroup(&facade)
+		require.NoError(t, err)
+
+		ws := startWebServer(nodeGroup, "node", getNodeRoutesConfig())
+
+		req, _ := http.NewRequest("GET", "/node/waiting-epochs-left/key", nil)
+		resp := httptest.NewRecorder()
+		ws.ServeHTTP(resp, req)
+
+		response := &shared.GenericAPIResponse{}
+		loadResponse(resp.Body, response)
+
+		assert.Equal(t, http.StatusInternalServerError, resp.Code)
+		assert.True(t, strings.Contains(response.Error, expectedErr.Error()))
+	})
+	t.Run("should work", func(t *testing.T) {
+		t.Parallel()
+
+		providedEpochsLeft := uint32(10)
+		facade := mock.FacadeStub{
+			GetWaitingEpochsLeftForPublicKeyCalled: func(publicKey string) (uint32, error) {
+				return providedEpochsLeft, nil
+			},
+		}
+
+		nodeGroup, err := groups.NewNodeGroup(&facade)
+		require.NoError(t, err)
+
+		ws := startWebServer(nodeGroup, "node", getNodeRoutesConfig())
+
+		req, _ := http.NewRequest("GET", "/node/waiting-epochs-left/key", nil)
+		resp := httptest.NewRecorder()
+		ws.ServeHTTP(resp, req)
+
+		response := &waitingEpochsLeftResponse{}
+		loadResponse(resp.Body, response)
+
+		assert.Equal(t, http.StatusOK, resp.Code)
+		assert.Equal(t, "", response.Error)
+		assert.Equal(t, providedEpochsLeft, response.Data.EpochsLeft)
+	})
+}
+
 func TestNodeGroup_UpdateFacade(t *testing.T) {
 	t.Parallel()
 
@@ -962,6 +1048,7 @@ func getNodeRoutesConfig() config.ApiRoutesConfig {
 					{Name: "/managed-keys", Open: true},
 					{Name: "/managed-keys/eligible", Open: true},
 					{Name: "/managed-keys/waiting", Open: true},
+					{Name: "/waiting-epochs-left/:key", Open: true},
 				},
 			},
 		},