Add WithBlock DialOption

CHANGELOG.md

@@ -28,6 +28,7 @@
   ctx := peer.NewCallContext(context.Background(), pubKey)
   res, err := c.Gnip(ctx, &pb.GnipRequest{Body: "Gnip"})
   ```
+* Add a `WithBlock` DialOption which blocks the caller of Dial until the underlying connection is up.
 
 # 0.1.1
 

README.md

@@ -140,4 +140,4 @@ While the client's are connected, kill the server and see the client's enter a b
 
 - [ ] Improve Tests
 - [ ] Return a response status
-- [ ] Add a Blocking DialOption
+- [x] Add a Blocking DialOption

client.go

@@ -49,7 +49,10 @@ type ClientConn struct {
 	service *serviceInfo
 }
 
-// Dial creates a client connection to the given target.
+// Dial creates a client connection to the given target. By default, it's
+// a non-blocking dial (the function won't wait for connections to be
+// established, and connecting happens in the background). To make it a blocking
+// dial, use WithBlock() dial option.
 func Dial(target string, opts ...DialOption) (*ClientConn, error) {
 	cc := &ClientConn{
 		ctx:         context.Background(),
@@ -74,6 +77,14 @@ func Dial(target string, opts ...DialOption) (*ClientConn, error) {
 	addrConn.connect()
 	cc.conn = addrConn
 
+	if cc.dopts.block {
+		for {
+			if addrConn.state == connectivity.Ready {
+				break
+			}
+		}
+	}
+
 	return cc, nil
 }
 

dialoptions.go

@@ -14,6 +14,7 @@ import (
 type dialOptions struct {
 	copts transport.ConnectOptions
 	bs    backoff.Strategy
+	block bool
 }
 
 // DialOption configures how we set up the connection.
@@ -54,6 +55,15 @@ func WithTransportCreds(privKey ed25519.PrivateKey, serverPubKey ed25519.PublicK
 	})
 }
 
+// WithBlock returns a DialOption which makes caller of Dial blocks until the
+// underlying connection is up. Without this, Dial returns immediately and
+// connecting the server happens in background.
+func WithBlock() DialOption {
+	return newFuncDialOption(func(o *dialOptions) {
+		o.block = true
+	})
+}
+
 func defaultDialOptions() dialOptions {
 	return dialOptions{
 		copts: transport.ConnectOptions{},

examples/simple/client/main.go

@@ -28,7 +28,10 @@ func main() {
 	privKey := keys.FromHex(keys.Clients[cidx].PrivKey)
 	serverPubKey := keys.FromHex(keys.ServerPubKey)
 
-	conn, err := wsrpc.Dial("127.0.0.1:1338", wsrpc.WithTransportCreds(privKey, serverPubKey))
+	conn, err := wsrpc.Dial("127.0.0.1:1338",
+		wsrpc.WithTransportCreds(privKey, serverPubKey),
+		wsrpc.WithBlock(),
+	)
 	if err != nil {
 		log.Fatalln(err)
 	}

wsrpclog/logger.go

@@ -0,0 +1,59 @@
+package wsrpclog
+
+import "log"
+
+// Logger defines a simple logger interface. We may want to consider improving
+// logging capabilities.
+type Logger interface {
+	Print(v ...interface{})
+	Printf(format string, v ...interface{})
+	Println(v ...interface{})
+}
+
+var (
+	Default Logger
+)
+
+func init() {
+	Default = &logger{}
+}
+
+func SetVerboseLogger() {
+	Default = &logger{Verbose: true}
+}
+
+type logger struct {
+	Verbose bool
+}
+
+var _ Logger = (*logger)(nil)
+
+func (l *logger) Print(v ...interface{}) {
+	if l.Verbose {
+		log.Println(v...)
+	}
+}
+
+func (l *logger) Printf(format string, v ...interface{}) {
+	if l.Verbose {
+		log.Printf(format, v...)
+	}
+}
+
+func (l *logger) Println(v ...interface{}) {
+	if l.Verbose {
+		log.Println(v...)
+	}
+}
+
+func Print(v ...interface{}) {
+	Default.Print(v...)
+}
+
+func Printf(format string, v ...interface{}) {
+	Default.Printf(format, v...)
+}
+
+func Println(v ...interface{}) {
+	Default.Println(v...)
+}