Rc/v1.6.0

.gitignore

@@ -24,3 +24,8 @@
 
 logs
 vendor
+
+# python
+__pycache__/
+*.py[cod]
+*$py.class

Makefile

@@ -31,23 +31,23 @@ help:
 
 build:
 	cd ${cmd_dir} && \
-		go build -o ${binary}
+		go build -v -ldflags="-X main.appVersion=$(git describe --tags --long --dirty)" -o ${binary}
 
-api_type="rabbit-api"
+publisher_type="rabbitmq"
 run: build
 	cd ${cmd_dir} && \
-		./${binary} --api-type=${api_type} --log-level="*:DEBUG"
+		./${binary} --publisher-type=${publisher_type} --log-level="*:DEBUG"
 
 runb: build
 	cd ${cmd_dir} && \
-		(./${binary} --api-type=${api_type} & echo $$! > ./${binary}.pid)
+		(./${binary} --publisher-type=${publisher_type} & echo $$! > ./${binary}.pid)
 
 kill:
 	kill $(shell cat ${cmd_dir}/${binary}.pid)
 
 debug: build
 	cd ${cmd_dir} && \
-		${debugger} exec ./${binary} -- --api-type=${api_type}
+		${debugger} exec ./${binary} -- --publisher-type=${publisher_type}
 
 debug-ath:
 	${debugger} attach $$(cat ${cmd_dir}/${binary}.pid)
@@ -71,7 +71,7 @@ docker-new: docker-build
 		--network "host" \
 		--name ${container_name} \
 		${image}:${image_tag} \
-		--api-type ${api_type} --log-level="*:DEBUG"
+		--publisher-type ${publisher_type} --log-level="*:DEBUG"
 
 docker-start:
 	docker start ${container_name}

README.md

@@ -11,40 +11,17 @@ has to setup one or multiple observers. For running an observing squad,
 these [docs](https://docs.multiversx.com/integrators/observing-squad/) 
 cover the whole process. 
 
+The observer node can be connected using WebSocket integration. Please check observer
+node config for setting up the connector. Enable `HostDriversConfig` in order to use
+WebSocket integration.
+
 The required configs for launching an observer/s with a driver attached,
 can be found [here](https://github.com/multiversx/mx-chain-go/blob/master/cmd/node/config/external.toml).
 
-The supported config variables are as follows:
-
-- `Enabled`: signals whether a driver should be attached when launching the node.
-- `UseAuthorization`: signal whether to use authorization. For testing purposes it can be set to `false`.
-- `ProxyUrl`: host and port on which the `eventNotifier` will push the parsed event data.
-- `Username`: the username used for authorization.
-- `Password`: the password used for authorization.
-
-The corresponding config section for enabling the driver:
-
-```toml
-[EventNotifierConnector]
-    # Enabled will turn on or off the event notifier connector
-    Enabled = true
-
-    # UseAuthorization signals the proxy to use authorization
-    # Never run a production setup without authorization
-    UseAuthorization = false
-
-    # ProxyUrl is used to communicate with the subscriptions hub
-    # The indexer instance will broadcast data using ProxyUrl
-    ProxyUrl = "http://localhost:5000"
-
-    # Username and Password need to be specified if UseAuthorization is set to true
-    Username = ""
+The HTTP integration is still available for backwards compatibility, but it will be
+deprecated in the future.
 
-    # Password is used to authorize an observer to push event data
-    Password = ""
-```
-
-## Install
+## How to run
 
 Using the `cmd/notifier` package as root, execute the following commands:
 
@@ -55,29 +32,31 @@ Using the `cmd/notifier` package as root, execute the following commands:
 ---
 This can also be done using a single command from `Makefile`:
 ```bash
-# by default, rabbit-api type
+# by default, rabbitmq type
 make run
 
-# specify notifier running mode (eq: rabbit-api, notifier)
-make run api_type=rabbit-api
+# specify notifier running mode (eq: rabbitmq, ws)
+make run publisher_type=rabbitmq
 ```
 
-## Launching the proxy
 
 CLI: run `--help` to get the command line parameters
 ```bash
 ./cmd/notifier/event-notifier --help
 ```
 
+### Prerequisites
+
 Before launching the proxy (notifier) service, it has to be configured so that it runs with the
-correct environment variables.
+correct config variables.
+
+The main config file can be found [here](https://github.com/multiversx/mx-chain-notifier-go/blob/main/cmd/notifier/config/config.toml).
 
 The supported config variables are:
 - `Host`: the host and port on which the http server listens on. Should be the same port
   as the one specified in the `ProxyUrl` described above.
 - `Username`: the username used to authorize an observer. Can be left empty for `UseAuthorization = false` on observer connector.
 - `Password`: the password used to authorize an observer. Can be left empty for `UseAuthorization = false` on observer connector.
-- `CheckDuplicates`: if true, it will check (based on a locker service using redis) if the event have been already pushed to clients
 
 If observer connector is set to use BasicAuth with `UseAuthorization = true`, `Username` and `Password` has to be
 set here on events notifier, and `Auth` flag has to be enabled in
@@ -90,14 +69,14 @@ For example:
         { Name = "/revert", Open = true, Auth = false },
 ```
 
-The main config file can be found [here](https://github.com/multiversx/mx-chain-notifier-go/blob/main/cmd/notifier/config/config.toml).
-
 After the configuration file is set up, the notifier instance can be
 launched.
 
-There are two ways in which notifier-go can be started:
-* `notifier` mode: it will launch a websocket handler (check [WebSockets](#websockets) section)
-* `rabbit-api` mode: it will set up a rabbitMQ client based on the RabbitMQ section from main config file (check [RabbitMQ](#rabbitmq) section)
+There are multiple publishing options when starting notifier service:
+* `ws`: it will launch a websocket handler (check [WebSockets](#websockets) section)
+* `rabbitmq`: it will set up a rabbitMQ client based on the RabbitMQ section from main config file (check [RabbitMQ](#rabbitmq) section)
+
+## Development setup
 
 There is a development setup using docker containers (with
 docker compose) that can be used for this.
@@ -113,7 +92,7 @@ events are being processed).
 * `notifier` mode can be launched as following (check `Makefile` for details): 
 ```bash
 # Starts setup with one notifier instance
-make docker-new api_type=notifier
+make docker-new publisher_type=ws
 
 # Stop notifier instance
 make docker-stop
@@ -140,7 +119,7 @@ make compose-rm
 
 Start Notifier instance
 ```bash
-make docker-new api_type=rabbit-api
+make docker-new publisher_type=rabbitmq
 ```
 
 ### API Endpoints

api/errors/errors.go

@@ -7,3 +7,6 @@ var ErrNilHTTPServer = errors.New("nil http server")
 
 // ErrNilFacadeHandler signals that a nil facade handler has been provided
 var ErrNilFacadeHandler = errors.New("nil facade handler")
+
+// ErrNilPayloadHandler signals that a nil payload handler has been provided
+var ErrNilPayloadHandler = errors.New("nil payload handler")

api/gin/webServer.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/gin-contrib/cors"
 	"github.com/gin-gonic/gin"
+	"github.com/multiversx/mx-chain-communication-go/websocket"
 	"github.com/multiversx/mx-chain-core-go/core/check"
 	logger "github.com/multiversx/mx-chain-logger-go"
 	apiErrors "github.com/multiversx/mx-chain-notifier-go/api/errors"
@@ -23,21 +24,28 @@ const (
 
 var log = logger.GetOrCreate("api/gin")
 
+const (
+	eventsGroupID = "events"
+	hubGroupID    = "hub"
+)
+
 // ArgsWebServerHandler holds the arguments needed to create a web server handler
 type ArgsWebServerHandler struct {
-	Facade  shared.FacadeHandler
-	Configs config.Configs
+	Facade         shared.FacadeHandler
+	PayloadHandler websocket.PayloadHandler
+	Configs        config.Configs
 }
 
 // webServer is a wrapper for gin.Engine, holding additional components
 type webServer struct {
 	sync.RWMutex
-	facade       shared.FacadeHandler
-	httpServer   shared.HTTPServerCloser
-	configs      config.Configs
-	groups       map[string]shared.GroupHandler
-	wasTriggered bool
-	cancelFunc   func()
+	facade         shared.FacadeHandler
+	payloadHandler websocket.PayloadHandler
+	httpServer     shared.HTTPServerCloser
+	groups         map[string]shared.GroupHandler
+	configs        config.Configs
+	wasTriggered   bool
+	cancelFunc     func()
 }
 
 // NewWebServerHandler creates and configures an instance of webServer
@@ -48,26 +56,30 @@ func NewWebServerHandler(args ArgsWebServerHandler) (*webServer, error) {
 	}
 
 	return &webServer{
-		facade:       args.Facade,
-		configs:      args.Configs,
-		groups:       make(map[string]shared.GroupHandler),
-		wasTriggered: false,
+		facade:         args.Facade,
+		payloadHandler: args.PayloadHandler,
+		configs:        args.Configs,
+		groups:         make(map[string]shared.GroupHandler),
+		wasTriggered:   false,
 	}, nil
 }
 
 func checkArgs(args ArgsWebServerHandler) error {
 	if check.IfNil(args.Facade) {
 		return apiErrors.ErrNilFacadeHandler
 	}
-	if args.Configs.Flags.APIType == "" {
+	if args.Configs.Flags.PublisherType == "" {
 		return common.ErrInvalidAPIType
 	}
+	if check.IfNil(args.PayloadHandler) {
+		return apiErrors.ErrNilPayloadHandler
+	}
 
 	return nil
 }
 
 func (w *webServer) getWSAddr() string {
-	addr := w.configs.GeneralConfig.ConnectorApi.Host
+	addr := w.configs.MainConfig.ConnectorApi.Host
 	if addr == "" {
 		return defaultRestInterface
 	}
@@ -124,24 +136,31 @@ func (w *webServer) Run() error {
 func (w *webServer) createGroups() error {
 	groupsMap := make(map[string]shared.GroupHandler)
 
-	eventsGroup, err := groups.NewEventsGroup(w.facade)
-	if err != nil {
-		return err
+	eventsGroupArgs := groups.ArgsEventsGroup{
+		Facade:         w.facade,
+		PayloadHandler: w.payloadHandler,
+	}
+
+	if w.configs.MainConfig.ConnectorApi.Enabled {
+		eventsGroup, err := groups.NewEventsGroup(eventsGroupArgs)
+		if err != nil {
+			return err
+		}
+		groupsMap[eventsGroupID] = eventsGroup
 	}
-	groupsMap["events"] = eventsGroup
 
 	statusGroup, err := groups.NewStatusGroup(w.facade)
 	if err != nil {
 		return err
 	}
 	groupsMap["status"] = statusGroup
 
-	if w.configs.Flags.APIType == common.WSAPIType {
+	if w.configs.Flags.PublisherType == common.WSPublisherType {
 		hubHandler, err := groups.NewHubGroup(w.facade)
 		if err != nil {
 			return err
 		}
-		groupsMap["hub"] = hubHandler
+		groupsMap[hubGroupID] = hubHandler
 	}
 
 	w.groups = groupsMap

api/gin/webServer_test.go

@@ -3,6 +3,7 @@ package gin_test
 import (
 	"testing"
 
+	"github.com/multiversx/mx-chain-communication-go/testscommon"
 	"github.com/multiversx/mx-chain-core-go/core/check"
 	apiErrors "github.com/multiversx/mx-chain-notifier-go/api/errors"
 	"github.com/multiversx/mx-chain-notifier-go/api/gin"
@@ -14,15 +15,16 @@ import (
 
 func createMockArgsWebServerHandler() gin.ArgsWebServerHandler {
 	return gin.ArgsWebServerHandler{
-		Facade: &mocks.FacadeStub{},
+		Facade:         &mocks.FacadeStub{},
+		PayloadHandler: &testscommon.PayloadHandlerStub{},
 		Configs: config.Configs{
-			GeneralConfig: config.GeneralConfig{
+			MainConfig: config.MainConfig{
 				ConnectorApi: config.ConnectorApiConfig{
 					Host: "8080",
 				},
 			},
 			Flags: config.FlagsConfig{
-				APIType: "notifier",
+				PublisherType: "notifier",
 			},
 		},
 	}
@@ -42,11 +44,22 @@ func TestNewWebServerHandler(t *testing.T) {
 		require.Equal(t, apiErrors.ErrNilFacadeHandler, err)
 	})
 
+	t.Run("nil payload handler", func(t *testing.T) {
+		t.Parallel()
+
+		args := createMockArgsWebServerHandler()
+		args.PayloadHandler = nil
+
+		ws, err := gin.NewWebServerHandler(args)
+		require.True(t, check.IfNil(ws))
+		require.Equal(t, apiErrors.ErrNilPayloadHandler, err)
+	})
+
 	t.Run("invalid api type", func(t *testing.T) {
 		t.Parallel()
 
 		args := createMockArgsWebServerHandler()
-		args.Configs.Flags.APIType = ""
+		args.Configs.Flags.PublisherType = ""
 
 		ws, err := gin.NewWebServerHandler(args)
 		require.True(t, check.IfNil(ws))

api/groups/errors.go

@@ -0,0 +1,10 @@
+package groups
+
+import "errors"
+
+var errNilBlockData = errors.New("nil block data")
+var errNilTransactionPool = errors.New("nil transaction pool")
+var errNilHeaderGasConsumption = errors.New("nil header gas consumption")
+
+// ErrNilEventsDataHandler signals that a nil events data handler was provided
+var ErrNilEventsDataHandler = errors.New("nil events data handler")