Operator is using deprecated cache-managers endpoint for health check…

…s with Infinispan 15. Fixes infinispan#2094

pkg/infinispan/client/api/infinispan.go

@@ -163,3 +163,11 @@ type NotSupportedError struct {
 func (n *NotSupportedError) Error() string {
 	return fmt.Sprintf("Operation not supported with Operand Major Version'%s'", n.Version)
 }
+
+type PathResolver interface {
+	Caches(string) string
+	CacheManager(string) string
+	Container(string) string
+	Logging(string) string
+	Server(string) string
+}

pkg/infinispan/client/client.go

@@ -47,6 +47,7 @@ import (
 	"github.com/infinispan/infinispan-operator/pkg/infinispan/client/api"
 	v13 "github.com/infinispan/infinispan-operator/pkg/infinispan/client/v13"
 	v14 "github.com/infinispan/infinispan-operator/pkg/infinispan/client/v14"
+	v15 "github.com/infinispan/infinispan-operator/pkg/infinispan/client/v15"
 	"github.com/infinispan/infinispan-operator/pkg/infinispan/version"
 )
 
@@ -55,7 +56,9 @@ func New(operand version.Operand, client http.HttpClient) api.Infinispan {
 	switch operand.UpstreamVersion.Major {
 	case 13:
 		return v13.New(client)
-	default:
+	case 14:
 		return v14.New(client)
+	default:
+		return v15.New(client)
 	}
 }

pkg/infinispan/client/v13/backups_restores.go

@@ -12,38 +12,35 @@ import (
 	"github.com/infinispan/infinispan-operator/pkg/mime"
 )
 
-const (
-	BackupPath  = CacheManagerPath + "/backups"
-	RestorePath = CacheManagerPath + "/restores"
-)
-
 var validator = inputValidator.New()
 
 type backups struct {
+	api.PathResolver
 	httpClient.HttpClient
 }
 
 type restores struct {
+	api.PathResolver
 	httpClient.HttpClient
 }
 
 func (b backups) Create(name string, config *api.BackupConfig) (err error) {
-	url := fmt.Sprintf("%s/%s", BackupPath, name)
+	url := b.CacheManager("/backups/" + name)
 	return create(url, name, "backup", config, b)
 }
 
 func (b backups) Status(name string) (api.Status, error) {
-	url := fmt.Sprintf("%s/%s", BackupPath, name)
+	url := b.CacheManager("/backups/" + name)
 	return status(url, name, "Backup", b)
 }
 
 func (r restores) Create(name string, config *api.RestoreConfig) (err error) {
-	url := fmt.Sprintf("%s/%s", RestorePath, name)
+	url := r.CacheManager("/restores/" + name)
 	return create(url, name, "restore", config, r)
 }
 
 func (r restores) Status(name string) (api.Status, error) {
-	url := fmt.Sprintf("%s/%s", RestorePath, name)
+	url := r.CacheManager("/restores/" + name)
 	return status(url, name, "Restore", r)
 }
 

pkg/infinispan/client/v13/caches.go

@@ -14,19 +14,19 @@ import (
 	"github.com/infinispan/infinispan-operator/pkg/mime"
 )
 
-const CachesPath = BasePath + "/caches"
-
 type cache struct {
+	api.PathResolver
 	httpClient.HttpClient
 	name string
 }
 
 type caches struct {
+	api.PathResolver
 	httpClient.HttpClient
 }
 
 func (c *cache) url() string {
-	return fmt.Sprintf("%s/%s", CachesPath, url.PathEscape(c.name))
+	return fmt.Sprintf("%s/%s", c.Caches(""), url.PathEscape(c.name))
 }
 
 func (c *cache) entryUrl(key string) string {
@@ -172,7 +172,7 @@ func (c *cache) UpdateConfig(config string, contentType mime.MimeType) (err erro
 }
 
 func (c *caches) ConvertConfiguration(config string, contentType mime.MimeType, reqType mime.MimeType) (transformed string, err error) {
-	path := CachesPath + "?action=convert"
+	path := c.Caches("?action=convert")
 	headers := map[string]string{
 		"Accept":       string(reqType),
 		"Content-Type": string(contentType),
@@ -196,7 +196,7 @@ func (c *caches) EqualConfiguration(_, _ string) (bool, error) {
 }
 
 func (c *caches) Names() (names []string, err error) {
-	rsp, err := c.Get(CachesPath, nil)
+	rsp, err := c.Get(c.Caches(""), nil)
 	if err = httpClient.ValidateResponse(rsp, err, "getting caches", http.StatusOK); err != nil {
 		return
 	}

pkg/infinispan/client/v13/container.go

@@ -10,19 +10,13 @@ import (
 	"github.com/infinispan/infinispan-operator/pkg/infinispan/client/api"
 )
 
-const (
-	CacheManagerPath = BasePath + "/cache-managers/default"
-	ContainerPath    = BasePath + "/container"
-	HealthPath       = CacheManagerPath + "/health"
-	HealthStatusPath = HealthPath + "/status"
-)
-
-type container struct {
+type Container struct {
 	httpClient.HttpClient
+	api.PathResolver
 }
 
-func (c *container) Info() (info *api.ContainerInfo, err error) {
-	rsp, err := c.Get(CacheManagerPath, nil)
+func (c *Container) Info() (info *api.ContainerInfo, err error) {
+	rsp, err := c.Get(c.Container(""), nil)
 	defer func() {
 		err = httpClient.CloseBody(rsp, err)
 	}()
@@ -37,8 +31,8 @@ func (c *container) Info() (info *api.ContainerInfo, err error) {
 	return
 }
 
-func (c *container) HealthStatus() (status api.HealthStatus, err error) {
-	rsp, err := c.Get(HealthStatusPath, nil)
+func (c *Container) HealthStatus() (status api.HealthStatus, err error) {
+	rsp, err := c.Get(c.Container("/health/status"), nil)
 	defer func() {
 		err = httpClient.CloseBody(rsp, err)
 	}()
@@ -53,8 +47,8 @@ func (c *container) HealthStatus() (status api.HealthStatus, err error) {
 	return api.HealthStatus(string(all)), nil
 }
 
-func (c *container) Members() (members []string, err error) {
-	rsp, err := c.Get(HealthPath, nil)
+func (c *Container) Members() (members []string, err error) {
+	rsp, err := c.Get(c.Container("/health"), nil)
 	defer func() {
 		err = httpClient.CloseBody(rsp, err)
 	}()
@@ -76,40 +70,40 @@ func (c *container) Members() (members []string, err error) {
 	return health.ClusterHealth.Nodes, nil
 }
 
-func (c *container) Backups() api.Backups {
-	return &backups{c.HttpClient}
+func (c *Container) Backups() api.Backups {
+	return &backups{c.PathResolver, c.HttpClient}
 }
 
-func (c *container) RebalanceDisable() error {
+func (c *Container) RebalanceDisable() error {
 	return c.rebalance("disable-rebalancing")
 }
 
-func (c *container) RebalanceEnable() error {
+func (c *Container) RebalanceEnable() error {
 	return c.rebalance("enable-rebalancing")
 }
 
-func (c *container) rebalance(action string) error {
-	rsp, err := c.Post(CacheManagerPath+"?action="+action, "", nil)
+func (c *Container) rebalance(action string) error {
+	rsp, err := c.Post(c.CacheManager("?action="+action), "", nil)
 	defer func() {
 		err = httpClient.CloseBody(rsp, err)
 	}()
 	err = httpClient.ValidateResponse(rsp, err, fmt.Sprintf("during %s", action), http.StatusNoContent)
 	return err
 }
 
-func (c *container) Restores() api.Restores {
-	return &restores{c.HttpClient}
+func (c *Container) Restores() api.Restores {
+	return &restores{c.PathResolver, c.HttpClient}
 }
 
-func (c *container) Shutdown() (err error) {
-	rsp, err := c.Post(ContainerPath+"?action=shutdown", "", nil)
+func (c *Container) Shutdown() (err error) {
+	rsp, err := c.Post(c.Container("?action=shutdown"), "", nil)
 	defer func() {
 		err = httpClient.CloseBody(rsp, err)
 	}()
 	err = httpClient.ValidateResponse(rsp, err, "during graceful shutdown", http.StatusNoContent)
 	return err
 }
 
-func (c *container) Xsite() api.Xsite {
-	return &xsite{c.HttpClient}
+func (c *Container) Xsite() api.Xsite {
+	return &xsite{c.HttpClient, c.PathResolver}
 }

pkg/infinispan/client/v13/infinispan_v13.go

@@ -7,32 +7,38 @@ import (
 )
 
 const (
-	BasePath     = "rest/v2"
 	MajorVersion = "13"
 )
 
 type infinispan struct {
+	api.PathResolver
 	http.HttpClient
 }
 
 func New(client http.HttpClient) api.Infinispan {
-	return &infinispan{client}
+	return NewWithPathResolver(client, NewPathResolver())
+}
+
+func NewWithPathResolver(client http.HttpClient, pathResolver api.PathResolver) api.Infinispan {
+	return &infinispan{pathResolver, client}
 }
 
 func (i *infinispan) Cache(name string) api.Cache {
-	return &cache{i.HttpClient, name}
+	return &cache{i.PathResolver, i.HttpClient, name}
 }
 
 func (i *infinispan) Caches() api.Caches {
-	return &caches{i.HttpClient}
+	return &caches{i.PathResolver, i.HttpClient}
 }
 
 func (i *infinispan) Container() api.Container {
-	return &container{i.HttpClient}
+	return &Container{
+		HttpClient: i.HttpClient,
+	}
 }
 
 func (i *infinispan) Logging() api.Logging {
-	return &logging{i.HttpClient}
+	return &logging{i.PathResolver, i.HttpClient}
 }
 
 func (i *infinispan) Metrics() api.Metrics {
@@ -48,5 +54,5 @@ func (i *infinispan) ScriptCacheName() string {
 }
 
 func (i *infinispan) Server() api.Server {
-	return &server{i.HttpClient}
+	return &server{i.PathResolver, i.HttpClient}
 }

pkg/infinispan/client/v13/logging.go

@@ -7,16 +7,16 @@ import (
 	"strings"
 
 	httpClient "github.com/infinispan/infinispan-operator/pkg/http"
+	"github.com/infinispan/infinispan-operator/pkg/infinispan/client/api"
 )
 
-const LoggersPath = BasePath + "/logging/loggers"
-
 type logging struct {
+	api.PathResolver
 	httpClient.HttpClient
 }
 
 func (l *logging) GetLoggers() (lm map[string]string, err error) {
-	rsp, err := l.Get(LoggersPath, nil)
+	rsp, err := l.Get(l.Logging(""), nil)
 	defer func() {
 		err = httpClient.CloseBody(rsp, err)
 	}()
@@ -43,7 +43,7 @@ func (l *logging) GetLoggers() (lm map[string]string, err error) {
 }
 
 func (l *logging) SetLogger(name, level string) error {
-	path := fmt.Sprintf("%s/%s?level=%s", LoggersPath, name, strings.ToUpper(level))
+	path := l.Logging(fmt.Sprintf("/%s?level=%s", name, strings.ToUpper(level)))
 	rsp, err := l.Put(path, "", nil)
 	defer func() {
 		err = httpClient.CloseBody(rsp, err)

pkg/infinispan/client/v13/path_resolver.go

@@ -0,0 +1,31 @@
+package v13
+
+import "github.com/infinispan/infinispan-operator/pkg/infinispan/client/api"
+
+func NewPathResolver() api.PathResolver {
+	return &pathResolver{Root: "rest/v2"}
+}
+
+type pathResolver struct {
+	Root string
+}
+
+func (r *pathResolver) Caches(s string) string {
+	return r.Root + "/caches" + s
+}
+
+func (r *pathResolver) CacheManager(s string) string {
+	return r.Root + "/cache-managers/default" + s
+}
+
+func (r *pathResolver) Container(s string) string {
+	return r.Root + "/container" + s
+}
+
+func (r *pathResolver) Logging(s string) string {
+	return r.Root + "/logging/loggers" + s
+}
+
+func (r *pathResolver) Server(s string) string {
+	return r.Root + "/server" + s
+}

pkg/infinispan/client/v13/server.go

@@ -4,16 +4,16 @@ import (
 	"net/http"
 
 	httpClient "github.com/infinispan/infinispan-operator/pkg/http"
+	"github.com/infinispan/infinispan-operator/pkg/infinispan/client/api"
 )
 
-const ServerPath = BasePath + "/server"
-
 type server struct {
+	api.PathResolver
 	httpClient.HttpClient
 }
 
 func (s *server) Stop() (err error) {
-	rsp, err := s.Post(ServerPath+"?action=stop", "", nil)
+	rsp, err := s.Post(s.Server("?action=stop"), "", nil)
 	defer func() {
 		err = httpClient.CloseBody(rsp, err)
 	}()

pkg/infinispan/client/v13/xsite.go

@@ -6,16 +6,17 @@ import (
 	"net/http"
 
 	httpClient "github.com/infinispan/infinispan-operator/pkg/http"
+	"github.com/infinispan/infinispan-operator/pkg/infinispan/client/api"
 )
 
-const XSitePath = CacheManagerPath + "/x-site/backups"
-
 type xsite struct {
 	httpClient.HttpClient
+	api.PathResolver
 }
 
 func (x *xsite) PushAllState() (err error) {
-	rsp, err := x.Get(XSitePath, nil)
+	xsitePath := x.CacheManager("/x-site/backups")
+	rsp, err := x.Get(xsitePath, nil)
 	if err = httpClient.ValidateResponse(rsp, err, "Retrieving xsite status", http.StatusOK); err != nil {
 		return
 	}
@@ -38,7 +39,7 @@ func (x *xsite) PushAllState() (err error) {
 	// Statuses will be empty if no xsite caches are configured
 	for k, v := range statuses {
 		if v.Status == "online" {
-			url := fmt.Sprintf("%s/%s?action=start-push-state", XSitePath, k)
+			url := fmt.Sprintf("%s/%s?action=start-push-state", xsitePath, k)
 			rsp, err = x.Post(url, "", nil)
 			if err = httpClient.ValidateResponse(rsp, err, "Pushing xsite state", http.StatusOK); err != nil {
 				return

pkg/infinispan/client/v14/caches.go

@@ -5,16 +5,16 @@ import (
 
 	httpClient "github.com/infinispan/infinispan-operator/pkg/http"
 	"github.com/infinispan/infinispan-operator/pkg/infinispan/client/api"
-	v13 "github.com/infinispan/infinispan-operator/pkg/infinispan/client/v13"
 )
 
 type caches struct {
 	httpClient.HttpClient
 	api.Caches
+	api.PathResolver
 }
 
 func (c *caches) EqualConfiguration(a, b string) (bool, error) {
-	path := v13.CachesPath + "?action=compare"
+	path := c.PathResolver.Caches("?action=compare")
 	parts := map[string]string{
 		"a": a,
 		"b": b,