chore: simplified configuration error

Renamed ConfigurationCreationError to just configurationError.
Also, removed configuration error from some parts since the
configuration error does not provide additional context; in fact
it often just repeats the same information in the error output.

.vscode/gorums.txt

@@ -43,6 +43,7 @@ Meland's
 Meling
 memprofile
 multicast
+naddr
 obj's
 Paxos
 Pedersen

config.go

@@ -1,9 +1,5 @@
 package gorums
 
-import (
-	"fmt"
-)
-
 // RawConfiguration represents a static set of nodes on which quorum calls may be invoked.
 //
 // NOTE: mutating the configuration is not supported.
@@ -18,7 +14,7 @@ type RawConfiguration []*RawNode
 // using the And, WithNewNodes, Except, and WithoutNodes methods.
 func NewRawConfiguration(mgr *RawManager, opt NodeListOption) (nodes RawConfiguration, err error) {
 	if opt == nil {
-		return nil, ConfigCreationError(fmt.Errorf("missing required node list"))
+		return nil, configurationError("missing required node list")
 	}
 	return opt.newConfig(mgr)
 }

config_opts.go

@@ -17,19 +17,18 @@ type nodeIDMap struct {
 
 func (o nodeIDMap) newConfig(mgr *RawManager) (nodes RawConfiguration, err error) {
 	if len(o.idMap) == 0 {
-		return nil, ConfigCreationError(fmt.Errorf("node-to-ID map required: WithNodeMap"))
+		return nil, configurationError("missing required node map")
 	}
 	nodes = make(RawConfiguration, 0, len(o.idMap))
 	for naddr, id := range o.idMap {
 		node, found := mgr.Node(id)
 		if !found {
 			node, err = NewRawNodeWithID(naddr, id)
 			if err != nil {
-				return nil, ConfigCreationError(err)
+				return nil, err
 			}
-			err = mgr.AddNode(node)
-			if err != nil {
-				return nil, ConfigCreationError(err)
+			if err = mgr.AddNode(node); err != nil {
+				return nil, err
 			}
 		}
 		nodes = append(nodes, node)
@@ -52,18 +51,17 @@ type nodeList struct {
 
 func (o nodeList) newConfig(mgr *RawManager) (nodes RawConfiguration, err error) {
 	if len(o.addrsList) == 0 {
-		return nil, ConfigCreationError(fmt.Errorf("node addresses required: WithNodeList"))
+		return nil, configurationError("missing required node addresses")
 	}
 	nodes = make(RawConfiguration, 0, len(o.addrsList))
 	for _, naddr := range o.addrsList {
 		node, err := NewRawNode(naddr)
 		if err != nil {
-			return nil, ConfigCreationError(err)
+			return nil, err
 		}
 		if n, found := mgr.Node(node.ID()); !found {
-			err = mgr.AddNode(node)
-			if err != nil {
-				return nil, ConfigCreationError(err)
+			if err = mgr.AddNode(node); err != nil {
+				return nil, err
 			}
 		} else {
 			node = n
@@ -88,14 +86,14 @@ type nodeIDs struct {
 
 func (o nodeIDs) newConfig(mgr *RawManager) (nodes RawConfiguration, err error) {
 	if len(o.nodeIDs) == 0 {
-		return nil, ConfigCreationError(fmt.Errorf("node IDs required: WithNodeIDs"))
+		return nil, configurationError("missing required node IDs")
 	}
 	nodes = make(RawConfiguration, 0, len(o.nodeIDs))
 	for _, id := range o.nodeIDs {
 		node, found := mgr.Node(id)
 		if !found {
 			// Node IDs must have been registered previously
-			return nil, ConfigCreationError(fmt.Errorf("node ID %d not found", id))
+			return nil, configurationError(fmt.Sprintf("node %d not found", id))
 		}
 		nodes = append(nodes, node)
 	}

errors.go

@@ -5,10 +5,9 @@ import (
 	"fmt"
 )
 
-// ConfigCreationError returns an error reporting that a Configuration
-// could not be created due to err.
-func ConfigCreationError(err error) error {
-	return fmt.Errorf("could not create configuration: %s", err.Error())
+// configurationError reports that a Configuration could not be created.
+func configurationError(desc string) error {
+	return fmt.Errorf("configuration: %s", desc)
 }
 
 // A QuorumCallError is used to report that a quorum call failed.

mgr.go

@@ -113,13 +113,13 @@ func (m *RawManager) Size() (nodes int) {
 func (m *RawManager) AddNode(node *RawNode) error {
 	if _, found := m.Node(node.ID()); found {
 		// Node IDs must be unique
-		return fmt.Errorf("node ID %d already exists (%s)", node.ID(), node.Address())
+		return configurationError(fmt.Sprintf("node %d (%s) already exists", node.ID(), node.Address()))
 	}
 	if m.logger != nil {
-		m.logger.Printf("connecting to %s with id %d\n", node, node.id)
+		m.logger.Printf("Connecting to %s with id %d\n", node, node.id)
 	}
 	if err := node.connect(m); err != nil {
-		return fmt.Errorf("connection failed for %s: %w", node, err)
+		return err
 	}
 
 	m.mu.Lock()

mgr_test.go

@@ -41,10 +41,10 @@ func TestManagerAddNode(t *testing.T) {
 		id   uint32
 		err  string
 	}{
-		{"127.0.1.1:1234", 1, "node ID 1 already exists (127.0.1.1:1234)"},
+		{"127.0.1.1:1234", 1, "configuration: node 1 (127.0.1.1:1234) already exists"},
 		{"127.0.1.1:1234", 5, ""},
 		{"127.0.1.1:1234", 6, ""}, // TODO(meling) does it make sense to allow same addr:port for different IDs?
-		{"127.0.1.1:1234", 2, "node ID 2 already exists (127.0.1.1:1234)"},
+		{"127.0.1.1:1234", 2, "configuration: node 2 (127.0.1.1:1234) already exists"},
 	}
 	for _, test := range tests {
 		node, err := gorums.NewRawNodeWithID(test.addr, test.id)

node.go

@@ -36,7 +36,7 @@ type RawNode struct {
 func NewRawNode(addr string) (*RawNode, error) {
 	tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
 	if err != nil {
-		return nil, fmt.Errorf("node error: '%s' error: %v", addr, err)
+		return nil, err
 	}
 	h := fnv.New32a()
 	_, _ = h.Write([]byte(tcpAddr.String()))
@@ -50,7 +50,7 @@ func NewRawNode(addr string) (*RawNode, error) {
 func NewRawNodeWithID(addr string, id uint32) (*RawNode, error) {
 	tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
 	if err != nil {
-		return nil, fmt.Errorf("node error: '%s' error: %v", addr, err)
+		return nil, err
 	}
 	return &RawNode{
 		id:   id,