Rename raft operations to cluster. Fixes #2546

CHANGELOG.md

@@ -1,15 +1,24 @@
-# Release 1.3.4
+# Release 1.4.0
 
-# What's New
+## What's New
 
 * Moved `ziti ops verify-network` to `ziti ops verify network`
 * Moved `ziti ops verify traffic` to `ziti ops verify traffic`
 * Added `ziti ops verify ext-jwt-signer oidc` to help users with configuring OIDC external auth 
-
+* Use `cluster` consistently for cluster operations
 * Bug Fixes
 
+## Cluster Operations Naming
+
+The CLI tools under `ziti fabric raft` are now found at `ziti ops cluster`.
+
+The Raft APIs available in the fabric management API are now namespaced under Cluster instead.
+
 ## Component Updates and Bug Fixes
 
+* github.com/openziti/ziti: [v1.3.3 -> v1.4.0](https://github.com/openziti/ziti/compare/v1.3.3...v1.4.0)
+    * [Issue #2546](https://github.com/openziti/ziti/issues/2546) - Use consistent terminology for HA
+
 # Release 1.3.3
 
 # What's New

controller/api_impl/raft_router.go → controller/api_impl/cluster_router.go

@@ -21,77 +21,77 @@ import (
 	"github.com/openziti/foundation/v2/errorz"
 	"github.com/openziti/ziti/common/pb/cmd_pb"
 	"github.com/openziti/ziti/controller/apierror"
+	"github.com/openziti/ziti/controller/raft"
 	"net/http"
 	"time"
 
 	"github.com/go-openapi/runtime/middleware"
 	"github.com/openziti/ziti/controller/api"
 	"github.com/openziti/ziti/controller/network"
-	nfraft "github.com/openziti/ziti/controller/raft"
 	"github.com/openziti/ziti/controller/rest_model"
 	"github.com/openziti/ziti/controller/rest_server/operations"
-	"github.com/openziti/ziti/controller/rest_server/operations/raft"
+	"github.com/openziti/ziti/controller/rest_server/operations/cluster"
 )
 
 func init() {
-	r := NewRaftRouter()
+	r := NewClusterRouter()
 	AddRouter(r)
 }
 
-type RaftRouter struct {
+type ClusterRouter struct {
 }
 
-func NewRaftRouter() *RaftRouter {
-	return &RaftRouter{}
+func NewClusterRouter() *ClusterRouter {
+	return &ClusterRouter{}
 }
 
-func (r *RaftRouter) Register(fabricApi *operations.ZitiFabricAPI, wrapper RequestWrapper) {
-	fabricApi.RaftRaftListMembersHandler = raft.RaftListMembersHandlerFunc(func(params raft.RaftListMembersParams) middleware.Responder {
+func (r *ClusterRouter) Register(fabricApi *operations.ZitiFabricAPI, wrapper RequestWrapper) {
+	fabricApi.ClusterClusterListMembersHandler = cluster.ClusterListMembersHandlerFunc(func(params cluster.ClusterListMembersParams) middleware.Responder {
 		return wrapper.WrapRequest(r.listMembers, params.HTTPRequest, "", "")
 	})
 
-	fabricApi.RaftRaftMemberAddHandler = raft.RaftMemberAddHandlerFunc(func(params raft.RaftMemberAddParams) middleware.Responder {
+	fabricApi.ClusterClusterMemberAddHandler = cluster.ClusterMemberAddHandlerFunc(func(params cluster.ClusterMemberAddParams) middleware.Responder {
 		return wrapper.WrapRequest(func(network *network.Network, rc api.RequestContext) {
 			r.addMember(network, rc, params)
 		}, params.HTTPRequest, "", "")
 	})
 
-	fabricApi.RaftRaftMemberRemoveHandler = raft.RaftMemberRemoveHandlerFunc(func(params raft.RaftMemberRemoveParams) middleware.Responder {
+	fabricApi.ClusterClusterMemberRemoveHandler = cluster.ClusterMemberRemoveHandlerFunc(func(params cluster.ClusterMemberRemoveParams) middleware.Responder {
 		return wrapper.WrapRequest(func(network *network.Network, rc api.RequestContext) {
 			r.removeMember(network, rc, params)
 		}, params.HTTPRequest, "", "")
 	})
 
-	fabricApi.RaftRaftTransferLeadershipHandler = raft.RaftTransferLeadershipHandlerFunc(func(params raft.RaftTransferLeadershipParams) middleware.Responder {
+	fabricApi.ClusterClusterTransferLeadershipHandler = cluster.ClusterTransferLeadershipHandlerFunc(func(params cluster.ClusterTransferLeadershipParams) middleware.Responder {
 		return wrapper.WrapRequest(func(network *network.Network, rc api.RequestContext) {
 			r.transferLeadership(network, rc, params)
 		}, params.HTTPRequest, "", "")
 	})
 }
 
-func (r *RaftRouter) getRaftController(n *network.Network) *nfraft.Controller {
+func (r *ClusterRouter) getClusterController(n *network.Network) *raft.Controller {
 	if n.Dispatcher == nil {
 		return nil
 	}
 
-	if raftController, ok := n.Dispatcher.(*nfraft.Controller); ok {
-		return raftController
+	if ClusterController, ok := n.Dispatcher.(*raft.Controller); ok {
+		return ClusterController
 	}
 
 	return nil
 }
 
-func (r *RaftRouter) listMembers(n *network.Network, rc api.RequestContext) {
-	raftController := r.getRaftController(n)
-	if raftController != nil {
-		vals := make([]*rest_model.RaftMemberListValue, 0)
-		members, err := raftController.ListMembers()
+func (r *ClusterRouter) listMembers(n *network.Network, rc api.RequestContext) {
+	ClusterController := r.getClusterController(n)
+	if ClusterController != nil {
+		vals := make([]*rest_model.ClusterMemberListValue, 0)
+		members, err := ClusterController.ListMembers()
 		if err != nil {
-			rc.Respond(rest_model.RaftMemberListResponse{}, http.StatusInternalServerError)
+			rc.Respond(rest_model.ClusterMemberListResponse{}, http.StatusInternalServerError)
 		}
-		readOnly := raftController.Mesh.IsReadOnly()
+		readOnly := ClusterController.Mesh.IsReadOnly()
 		for _, member := range members {
-			vals = append(vals, &rest_model.RaftMemberListValue{
+			vals = append(vals, &rest_model.ClusterMemberListValue{
 				Address:   &member.Addr,
 				Connected: &member.Connected,
 				ID:        &member.Id,
@@ -102,7 +102,7 @@ func (r *RaftRouter) listMembers(n *network.Network, rc api.RequestContext) {
 			})
 		}
 
-		rc.Respond(rest_model.RaftMemberListResponse{
+		rc.Respond(rest_model.ClusterMemberListResponse{
 			Data: vals,
 		}, http.StatusOK)
 
@@ -111,11 +111,11 @@ func (r *RaftRouter) listMembers(n *network.Network, rc api.RequestContext) {
 	}
 }
 
-func (r *RaftRouter) addMember(n *network.Network, rc api.RequestContext, params raft.RaftMemberAddParams) {
-	raftController := r.getRaftController(n)
-	if raftController != nil {
+func (r *ClusterRouter) addMember(n *network.Network, rc api.RequestContext, params cluster.ClusterMemberAddParams) {
+	ClusterController := r.getClusterController(n)
+	if ClusterController != nil {
 		addr := *params.Member.Address
-		peerId, peerAddr, err := raftController.Mesh.GetPeerInfo(addr, 15*time.Second)
+		peerId, peerAddr, err := ClusterController.Mesh.GetPeerInfo(addr, 15*time.Second)
 		if err != nil {
 			msg := fmt.Sprintf("unable to retrieve cluster member id [%s] for supplied address", err.Error())
 			rc.RespondWithApiError(apierror.NewBadRequestFieldError(*errorz.NewFieldError(msg, "address", addr)))
@@ -131,7 +131,7 @@ func (r *RaftRouter) addMember(n *network.Network, rc api.RequestContext, params
 			IsVoter: *params.Member.IsVoter,
 		}
 
-		if err = raftController.Join(req); err != nil {
+		if err = ClusterController.Join(req); err != nil {
 			msg := fmt.Sprintf("unable to add cluster member for supplied address: [%s]", err.Error())
 			rc.RespondWithApiError(apierror.NewBadRequestFieldError(*errorz.NewFieldError(msg, "address", addr)))
 			return
@@ -144,14 +144,14 @@ func (r *RaftRouter) addMember(n *network.Network, rc api.RequestContext, params
 	}
 }
 
-func (r *RaftRouter) removeMember(n *network.Network, rc api.RequestContext, params raft.RaftMemberRemoveParams) {
-	raftController := r.getRaftController(n)
-	if raftController != nil {
+func (r *ClusterRouter) removeMember(n *network.Network, rc api.RequestContext, params cluster.ClusterMemberRemoveParams) {
+	ClusterController := r.getClusterController(n)
+	if ClusterController != nil {
 		req := &cmd_pb.RemovePeerRequest{
 			Id: *params.Member.ID,
 		}
 
-		if err := raftController.HandleRemovePeer(req); err != nil {
+		if err := ClusterController.HandleRemovePeer(req); err != nil {
 			msg := fmt.Sprintf("unable to remove cluster member node for supplied node id: [%s]", err.Error())
 			rc.RespondWithApiError(apierror.NewBadRequestFieldError(*errorz.NewFieldError(msg, "id", *params.Member.ID)))
 			return
@@ -164,14 +164,14 @@ func (r *RaftRouter) removeMember(n *network.Network, rc api.RequestContext, par
 	}
 }
 
-func (r *RaftRouter) transferLeadership(n *network.Network, rc api.RequestContext, params raft.RaftTransferLeadershipParams) {
-	raftController := r.getRaftController(n)
-	if raftController != nil {
+func (r *ClusterRouter) transferLeadership(n *network.Network, rc api.RequestContext, params cluster.ClusterTransferLeadershipParams) {
+	ClusterController := r.getClusterController(n)
+	if ClusterController != nil {
 		req := &cmd_pb.TransferLeadershipRequest{
 			Id: params.Member.NewLeaderID,
 		}
 
-		if err := raftController.HandleTransferLeadership(req); err != nil {
+		if err := ClusterController.HandleTransferLeadership(req); err != nil {
 			rc.RespondWithApiError(&errorz.ApiError{
 				Code:        apierror.TransferLeadershipErrorCode,
 				Message:     apierror.TransferLeadershipErrorMessage,