service discovery v3 - gateway & kollector deprecation

go.mod

@@ -17,6 +17,8 @@ require (
 	github.com/stretchr/testify v1.8.4
 	go.opentelemetry.io/otel v1.22.0
 	golang.org/x/mod v0.15.0
+	k8s.io/apimachinery v0.29.2
+	k8s.io/client-go v0.29.2
 )
 
 require (
@@ -165,8 +167,6 @@ require (
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	k8s.io/api v0.29.2 // indirect
-	k8s.io/apimachinery v0.29.2 // indirect
-	k8s.io/client-go v0.29.2 // indirect
 	k8s.io/klog/v2 v2.110.1 // indirect
 	k8s.io/kube-openapi v0.0.0-20231010175941-2dd684a91f00 // indirect
 	k8s.io/utils v0.0.0-20230726121419-3b25d923346b // indirect

pkg/servicediscovery/schema/interface.go

@@ -7,13 +7,17 @@ import (
 
 type IBackendServices interface {
 	SetReportReceiverHttpUrl(string)
+	// deprecated
 	SetReportReceiverWebsocketUrl(string)
+	// deprecated
 	SetGatewayUrl(string)
 	SetApiServerUrl(string)
 	SetMetricsUrl(string)
 	SetSynchronizerUrl(string)
 	GetReportReceiverHttpUrl() string
+	// deprecated
 	GetReportReceiverWebsocketUrl() string
+	// deprecated
 	GetGatewayUrl() string
 	GetApiServerUrl() string
 	GetMetricsUrl() string

pkg/servicediscovery/servicediscovery.go

@@ -11,6 +11,7 @@ import (
 var supporterVersions = []string{
 	"v1",
 	"v2",
+	"v3",
 }
 
 // WriteServiceDiscoveryResponse writes the service discovery response to the HTTP response writer

pkg/servicediscovery/servicediscovery_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/kubescape/backend/pkg/servicediscovery/schema"
 	v1 "github.com/kubescape/backend/pkg/servicediscovery/v1"
 	v2 "github.com/kubescape/backend/pkg/servicediscovery/v2"
+	v3 "github.com/kubescape/backend/pkg/servicediscovery/v3"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -19,6 +20,10 @@ var _ schema.IServiceDiscoveryClient = &v1.ServiceDiscoveryClientV1{}
 var _ schema.IServiceDiscoveryServer = &v2.ServiceDiscoveryServerV2{}
 var _ schema.IServiceDiscoveryClient = &v2.ServiceDiscoveryClientV2{}
 
+// v3
+var _ schema.IServiceDiscoveryServer = &v3.ServiceDiscoveryServerV3{}
+var _ schema.IServiceDiscoveryClient = &v3.ServiceDiscoveryClientV3{}
+
 var testUrl string
 var testVersion string
 
@@ -150,3 +155,72 @@ func TestServiceDiscoveryStreamV2(t *testing.T) {
 	assert.NotEmpty(t, services.GetReportReceiverWebsocketUrl())
 	assert.NotEmpty(t, services.GetSynchronizerUrl())
 }
+
+func TestServiceDiscoveryClientV3(t *testing.T) {
+	flag.Parse()
+	if testUrl == "" {
+		t.Skip("skipping test because no URL was provided")
+	}
+	if testVersion != "v3" {
+		t.Skip()
+	}
+
+	client, err := v3.NewServiceDiscoveryClientV3(testUrl)
+	if err != nil {
+		t.Fatalf("failed to create client: %s", err.Error())
+	}
+	sdUrl := client.GetServiceDiscoveryUrl()
+	t.Logf("testing URL: %s", sdUrl)
+	services, err := GetServices(client)
+	if err != nil {
+		assert.FailNowf(t, fmt.Sprintf("failed to get services from url: %s (HTTP GET)", sdUrl), err.Error())
+	}
+
+	assert.NotNil(t, services)
+	assert.NotEmpty(t, services.GetApiServerUrl())
+	assert.NotEmpty(t, services.GetMetricsUrl())
+	assert.NotEmpty(t, services.GetReportReceiverHttpUrl())
+	assert.NotEmpty(t, services.GetSynchronizerUrl())
+
+	// deprecated services
+	assert.Panics(t, func() { services.GetReportReceiverWebsocketUrl() })
+	assert.Panics(t, func() { services.GetGatewayUrl() })
+}
+
+func TestServiceDiscoveryFileV3(t *testing.T) {
+	file := v3.NewServiceDiscoveryFileV3("testdata/v3.json")
+	services, err := GetServices(file)
+	if err != nil {
+		assert.FailNowf(t, "failed to get services from file: %s", err.Error())
+	}
+
+	assert.NotNil(t, services)
+	assert.NotEmpty(t, services.GetApiServerUrl())
+	assert.NotEmpty(t, services.GetMetricsUrl())
+	assert.NotEmpty(t, services.GetReportReceiverHttpUrl())
+	assert.NotEmpty(t, services.GetSynchronizerUrl())
+
+	// deprecated services
+	assert.Panics(t, func() { services.GetReportReceiverWebsocketUrl() })
+	assert.Panics(t, func() { services.GetGatewayUrl() })
+}
+
+func TestServiceDiscoveryStreamV3(t *testing.T) {
+	stream := []byte("{\"version\": \"v3\",\"response\": {\"event-receiver-http\": \"https://er-test.com\",\"api-server\": \"https://api.test.com\",\"metrics\": \"https://metrics.test.com\", \"synchronizer\": \"wss://synchronizer.test.com\"}}")
+	services, err := GetServices(
+		v3.NewServiceDiscoveryStreamV3(stream),
+	)
+	if err != nil {
+		assert.FailNowf(t, "failed to get services from stream: %s", err.Error())
+	}
+
+	assert.NotNil(t, services)
+	assert.NotEmpty(t, services.GetApiServerUrl())
+	assert.NotEmpty(t, services.GetMetricsUrl())
+	assert.NotEmpty(t, services.GetReportReceiverHttpUrl())
+	assert.NotEmpty(t, services.GetSynchronizerUrl())
+
+	// deprecated services
+	assert.Panics(t, func() { services.GetReportReceiverWebsocketUrl() })
+	assert.Panics(t, func() { services.GetGatewayUrl() })
+}

pkg/servicediscovery/testdata/v3.json

@@ -0,0 +1,9 @@
+{
+    "version": "v3",
+    "response": {
+        "event-receiver-http": "https://er-test.com",
+        "api-server": "https://api.test.com",
+        "metrics": "https://metrics.test.com",
+        "synchronizer": "wss://synchronizer.test.com"
+    }
+}

pkg/servicediscovery/v3/consts.go

@@ -0,0 +1,6 @@
+package v3
+
+const (
+	ServiceDiscoveryPathV3 = "/api/v3/servicediscovery"
+	ApiVersion             = "v3"
+)

pkg/servicediscovery/v3/datastructuremethods.go

@@ -0,0 +1,162 @@
+package v3
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+
+	"github.com/kubescape/backend/pkg/servicediscovery/schema"
+	"github.com/kubescape/backend/pkg/utils"
+)
+
+func NewServiceDiscoveryClientV3(url string) (*ServiceDiscoveryClientV3, error) {
+	scheme, host, err := utils.ParseHost(url)
+	if err != nil {
+		return nil, err
+	}
+	return &ServiceDiscoveryClientV3{scheme: scheme, host: host, path: ServiceDiscoveryPathV3}, nil
+}
+
+func (sds *ServiceDiscoveryClientV3) GetServiceDiscoveryUrl() string {
+	u := url.URL{
+		Host:   sds.host,
+		Scheme: sds.scheme,
+		Path:   sds.path,
+	}
+	return u.String()
+}
+
+func (sds *ServiceDiscoveryClientV3) GetHost() string {
+	return sds.host
+}
+func (sds *ServiceDiscoveryClientV3) GetPath() string {
+	return sds.path
+}
+
+func (sds *ServiceDiscoveryClientV3) GetScheme() string {
+	return sds.scheme
+}
+
+func (sds *ServiceDiscoveryClientV3) ParseResponse(response json.RawMessage) (schema.IBackendServices, error) {
+	var services ServicesV3
+	if err := json.Unmarshal(response, &services); err == nil {
+		return &services, nil
+	}
+
+	return nil, fmt.Errorf("invalid response")
+}
+
+func (sds *ServiceDiscoveryClientV3) Get() (io.Reader, error) {
+	response, err := http.Get(sds.GetServiceDiscoveryUrl())
+	if err != nil {
+		return nil, err
+	}
+
+	if response.StatusCode < 200 || response.StatusCode >= 300 {
+		return nil, fmt.Errorf("server (%s) responded: %v", sds.GetHost(), response.StatusCode)
+	}
+	return response.Body, nil
+}
+
+func NewServiceDiscoveryServerV3(services ServicesV3) *ServiceDiscoveryServerV3 {
+	return &ServiceDiscoveryServerV3{version: ApiVersion, services: services}
+}
+
+func (sds *ServiceDiscoveryServerV3) GetResponse() json.RawMessage {
+	resp, _ := json.Marshal(sds.services)
+	return resp
+}
+
+func (sds *ServiceDiscoveryServerV3) GetVersion() string {
+	return sds.version
+}
+
+func (sds *ServiceDiscoveryServerV3) GetCachedResponse() ([]byte, bool) {
+	return sds.cachedResponse, sds.cachedResponse != nil
+}
+
+func (sds *ServiceDiscoveryServerV3) CacheResponse(response []byte) {
+	if sds.cachedResponse == nil {
+		sds.cachedResponse = response
+	}
+}
+
+func (s *ServicesV3) SetReportReceiverHttpUrl(val string) {
+	s.EventReceiverHttpUrl = val
+}
+
+func (s *ServicesV3) SetApiServerUrl(val string) {
+	s.ApiServerUrl = val
+}
+
+func (s *ServicesV3) SetMetricsUrl(val string) {
+	s.MetricsUrl = val
+}
+
+func (s *ServicesV3) GetReportReceiverHttpUrl() string {
+	return s.EventReceiverHttpUrl
+}
+
+func (s *ServicesV3) GetApiServerUrl() string {
+	return s.ApiServerUrl
+}
+
+func (s *ServicesV3) GetMetricsUrl() string {
+	return s.MetricsUrl
+}
+
+func (s *ServicesV3) SetSynchronizerUrl(val string) {
+	s.SynchronizerUrl = val
+}
+
+func (s *ServicesV3) GetSynchronizerUrl() string {
+	return s.SynchronizerUrl
+}
+
+func NewServiceDiscoveryFileV3(path string) *ServiceDiscoveryFileV3 {
+	return &ServiceDiscoveryFileV3{path: path}
+}
+
+func (s *ServiceDiscoveryFileV3) Get() (io.Reader, error) {
+	jsonFile, err := os.Open(s.path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file (%s): %v", s.path, err)
+	}
+	data, err := io.ReadAll(jsonFile)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read file (%s): %v", s.path, err)
+	}
+	jsonFile.Close()
+
+	return bytes.NewReader(data), nil
+}
+
+func (s *ServiceDiscoveryFileV3) ParseResponse(response json.RawMessage) (schema.IBackendServices, error) {
+	var services ServicesV3
+	if err := json.Unmarshal(response, &services); err == nil {
+		return &services, nil
+	}
+
+	return nil, fmt.Errorf("invalid response")
+}
+
+func NewServiceDiscoveryStreamV3(data []byte) *ServiceDiscoveryStreamV3 {
+	return &ServiceDiscoveryStreamV3{data: data}
+}
+
+func (s *ServiceDiscoveryStreamV3) Get() (io.Reader, error) {
+	return bytes.NewReader(s.data), nil
+}
+
+func (s *ServiceDiscoveryStreamV3) ParseResponse(response json.RawMessage) (schema.IBackendServices, error) {
+	var services ServicesV3
+	if err := json.Unmarshal(response, &services); err == nil {
+		return &services, nil
+	}
+
+	return nil, fmt.Errorf("invalid response")
+}

pkg/servicediscovery/v3/datastructures.go

@@ -0,0 +1,32 @@
+package v3
+
+import "github.com/kubescape/backend/pkg/servicediscovery/schema"
+
+type ServiceDiscoveryClientV3 struct {
+	host   string
+	scheme string
+	path   string
+}
+
+type ServiceDiscoveryServerV3 struct {
+	version        string
+	services       ServicesV3
+	cachedResponse []byte
+}
+
+type ServicesV3 struct {
+	schema.IBackendServices `json:"-"`
+
+	EventReceiverHttpUrl string `json:"event-receiver-http"`
+	ApiServerUrl         string `json:"api-server"`
+	MetricsUrl           string `json:"metrics"`
+	SynchronizerUrl      string `json:"synchronizer"`
+}
+
+type ServiceDiscoveryFileV3 struct {
+	path string
+}
+
+type ServiceDiscoveryStreamV3 struct {
+	data []byte
+}