Merge pull request #113 from cloudstruct/feature/functional-options

feat: use functional options pattern for config

Author: agaffney

cmd/go-ouroboros-network/chainsync.go

@@ -111,21 +111,20 @@ func testChainSync(f *globalFlags) {
 
 	conn := createClientConnection(f)
 	errorChan := make(chan error)
-	oOpts := &ouroboros.OuroborosOptions{
-		Conn:                  conn,
-		NetworkMagic:          uint32(f.networkMagic),
-		ErrorChan:             errorChan,
-		UseNodeToNodeProtocol: f.ntnProto,
-		SendKeepAlives:        true,
-	}
 	go func() {
 		for {
 			err := <-errorChan
 			fmt.Printf("ERROR: %s\n", err)
 			os.Exit(1)
 		}
 	}()
-	o, err := ouroboros.New(oOpts)
+	o, err := ouroboros.New(
+		ouroboros.WithConnection(conn),
+		ouroboros.WithNetworkMagic(uint32(f.networkMagic)),
+		ouroboros.WithErrorChan(errorChan),
+		ouroboros.WithNodeToNode(f.ntnProto),
+		ouroboros.WithKeepAlive(true),
+	)
 	if err != nil {
 		fmt.Printf("ERROR: %s\n", err)
 		os.Exit(1)

cmd/go-ouroboros-network/localtxsubmission.go

@@ -50,21 +50,20 @@ func testLocalTxSubmission(f *globalFlags) {
 
 	conn := createClientConnection(f)
 	errorChan := make(chan error)
-	oOpts := &ouroboros.OuroborosOptions{
-		Conn:                  conn,
-		NetworkMagic:          uint32(f.networkMagic),
-		ErrorChan:             errorChan,
-		UseNodeToNodeProtocol: f.ntnProto,
-		SendKeepAlives:        true,
-	}
 	go func() {
 		for {
 			err := <-errorChan
 			fmt.Printf("ERROR: %s\n", err)
 			os.Exit(1)
 		}
 	}()
-	o, err := ouroboros.New(oOpts)
+	o, err := ouroboros.New(
+		ouroboros.WithConnection(conn),
+		ouroboros.WithNetworkMagic(uint32(f.networkMagic)),
+		ouroboros.WithErrorChan(errorChan),
+		ouroboros.WithNodeToNode(f.ntnProto),
+		ouroboros.WithKeepAlive(true),
+	)
 	if err != nil {
 		fmt.Printf("ERROR: %s\n", err)
 		os.Exit(1)

cmd/go-ouroboros-network/server.go

@@ -62,20 +62,19 @@ func testServer(f *globalFlags) {
 			continue
 		}
 		errorChan := make(chan error)
-		oOpts := &ouroboros.OuroborosOptions{
-			Conn:                  conn,
-			NetworkMagic:          uint32(f.networkMagic),
-			ErrorChan:             errorChan,
-			UseNodeToNodeProtocol: f.ntnProto,
-			Server:                true,
-		}
 		go func() {
 			for {
 				err := <-errorChan
 				fmt.Printf("ERROR: %s\n", err)
 			}
 		}()
-		_, err = ouroboros.New(oOpts)
+		_, err = ouroboros.New(
+			ouroboros.WithConnection(conn),
+			ouroboros.WithNetworkMagic(uint32(f.networkMagic)),
+			ouroboros.WithErrorChan(errorChan),
+			ouroboros.WithNodeToNode(f.ntnProto),
+			ouroboros.WithServer(true),
+		)
 		if err != nil {
 			fmt.Printf("ERROR: %s\n", err)
 		}

options.go

@@ -0,0 +1,55 @@
+package ouroboros
+
+import (
+	"net"
+)
+
+type OuroborosOptionFunc func(*Ouroboros)
+
+func WithConnection(conn net.Conn) OuroborosOptionFunc {
+	return func(o *Ouroboros) {
+		o.conn = conn
+	}
+}
+
+func WithNetworkMagic(networkMagic uint32) OuroborosOptionFunc {
+	return func(o *Ouroboros) {
+		o.networkMagic = networkMagic
+	}
+}
+
+func WithErrorChan(errorChan chan error) OuroborosOptionFunc {
+	return func(o *Ouroboros) {
+		o.ErrorChan = errorChan
+	}
+}
+
+func WithServer(server bool) OuroborosOptionFunc {
+	return func(o *Ouroboros) {
+		o.server = server
+	}
+}
+
+func WithNodeToNode(nodeToNode bool) OuroborosOptionFunc {
+	return func(o *Ouroboros) {
+		o.useNodeToNodeProto = nodeToNode
+	}
+}
+
+func WithKeepAlive(keepAlive bool) OuroborosOptionFunc {
+	return func(o *Ouroboros) {
+		o.sendKeepAlives = keepAlive
+	}
+}
+
+func WithDelayMuxerStart(delayMuxerStart bool) OuroborosOptionFunc {
+	return func(o *Ouroboros) {
+		o.delayMuxerStart = delayMuxerStart
+	}
+}
+
+func WithFullDuplex(fullDuplex bool) OuroborosOptionFunc {
+	return func(o *Ouroboros) {
+		o.fullDuplex = fullDuplex
+	}
+}

ouroboros.go

@@ -36,28 +36,13 @@ type Ouroboros struct {
 	TxSubmission      *txsubmission.TxSubmission
 }
 
-type OuroborosOptions struct {
-	Conn                  net.Conn
-	NetworkMagic          uint32
-	ErrorChan             chan error
-	Server                bool
-	UseNodeToNodeProtocol bool
-	SendKeepAlives        bool
-	DelayMuxerStart       bool
-	FullDuplex            bool
-}
-
-func New(options *OuroborosOptions) (*Ouroboros, error) {
+func New(options ...OuroborosOptionFunc) (*Ouroboros, error) {
 	o := &Ouroboros{
-		conn:               options.Conn,
-		networkMagic:       options.NetworkMagic,
-		server:             options.Server,
-		useNodeToNodeProto: options.UseNodeToNodeProtocol,
-		ErrorChan:          options.ErrorChan,
-		sendKeepAlives:     options.SendKeepAlives,
-		delayMuxerStart:    options.DelayMuxerStart,
-		fullDuplex:         options.FullDuplex,
-		protoErrorChan:     make(chan error, 10),
+		protoErrorChan: make(chan error, 10),
+	}
+	// Apply provided options functions
+	for _, option := range options {
+		option(o)
 	}
 	if o.ErrorChan == nil {
 		o.ErrorChan = make(chan error, 10)

ouroboros_test.go

@@ -7,8 +7,7 @@ import (
 
 // Ensure that we don't panic when closing the Ouroboros object after a failed Dial() call
 func TestDialFailClose(t *testing.T) {
-	oOpts := &ouroboros.OuroborosOptions{}
-	oConn, err := ouroboros.New(oOpts)
+	oConn, err := ouroboros.New()
 	if err != nil {
 		t.Fatalf("unexpected error when creating Ouroboros object: %s", err)
 	}