all: zmq -> zmq4

Author: sbinet

kernel.go

@@ -16,7 +16,7 @@ import (
 	"sync"
 	"time"
 
-	zmq "github.com/go-zeromq/zmq4"
+	"github.com/go-zeromq/zmq4"
 	"golang.org/x/xerrors"
 
 	"github.com/cosmos72/gomacro/ast2"
@@ -48,7 +48,7 @@ type ConnectionInfo struct {
 
 // Socket wraps a zmq socket with a lock which should be used to control write access.
 type Socket struct {
-	Socket zmq.Socket
+	Socket zmq4.Socket
 	Lock   *sync.Mutex
 }
 
@@ -102,7 +102,7 @@ const (
 )
 
 // RunWithSocket invokes the `run` function after acquiring the `Socket.Lock` and releases the lock when done.
-func (s *Socket) RunWithSocket(run func(socket zmq.Socket) error) error {
+func (s *Socket) RunWithSocket(run func(socket zmq4.Socket) error) error {
 	s.Lock.Lock()
 	defer s.Lock.Unlock()
 	return run(s.Socket)
@@ -164,7 +164,7 @@ func runKernel(connectionFile string) {
 	// TODO gracefully shutdown the heartbeat handler on kernel shutdown by closing the chan returned by startHeartbeat.
 
 	type msgType struct {
-		Msg zmq.Msg
+		Msg zmq4.Msg
 		Err error
 	}
 
@@ -176,7 +176,7 @@ func runKernel(connectionFile string) {
 	)
 
 	defer close(quit)
-	poll := func(msgs chan msgType, sck zmq.Socket) {
+	poll := func(msgs chan msgType, sck zmq4.Socket) {
 		defer close(msgs)
 		for {
 			msg, err := sck.Recv()
@@ -250,27 +250,27 @@ func prepareSockets(connInfo ConnectionInfo) (SocketGroup, error) {
 
 	// Create the shell socket, a request-reply socket that may receive messages from multiple frontend for
 	// code execution, introspection, auto-completion, etc.
-	sg.ShellSocket.Socket = zmq.NewRouter(ctx)
+	sg.ShellSocket.Socket = zmq4.NewRouter(ctx)
 	sg.ShellSocket.Lock = &sync.Mutex{}
 
 	// Create the control socket. This socket is a duplicate of the shell socket where messages on this channel
 	// should jump ahead of queued messages on the shell socket.
-	sg.ControlSocket.Socket = zmq.NewRouter(ctx)
+	sg.ControlSocket.Socket = zmq4.NewRouter(ctx)
 	sg.ControlSocket.Lock = &sync.Mutex{}
 
 	// Create the stdin socket, a request-reply socket used to request user input from a front-end. This is analogous
 	// to a standard input stream.
-	sg.StdinSocket.Socket = zmq.NewRouter(ctx)
+	sg.StdinSocket.Socket = zmq4.NewRouter(ctx)
 	sg.StdinSocket.Lock = &sync.Mutex{}
 
 	// Create the iopub socket, a publisher for broadcasting data like stdout/stderr output, displaying execution
 	// results or errors, kernel status, etc. to connected subscribers.
-	sg.IOPubSocket.Socket = zmq.NewPub(ctx)
+	sg.IOPubSocket.Socket = zmq4.NewPub(ctx)
 	sg.IOPubSocket.Lock = &sync.Mutex{}
 
 	// Create the heartbeat socket, a request-reply socket that only allows alternating recv-send (request-reply)
 	// calls. It should echo the byte strings it receives to let the requester know the kernel is still alive.
-	sg.HBSocket.Socket = zmq.NewRep(ctx)
+	sg.HBSocket.Socket = zmq4.NewRep(ctx)
 	sg.HBSocket.Lock = &sync.Mutex{}
 
 	// Bind the sockets.
@@ -575,7 +575,7 @@ func startHeartbeat(hbSocket Socket, wg *sync.WaitGroup) (shutdown chan struct{}
 		defer wg.Done()
 
 		type msgType struct {
-			Msg zmq.Msg
+			Msg zmq4.Msg
 			Err error
 		}
 
@@ -604,7 +604,7 @@ func startHeartbeat(hbSocket Socket, wg *sync.WaitGroup) (shutdown chan struct{}
 			case <-timeout.C:
 				continue
 			case v := <-msgs:
-				hbSocket.RunWithSocket(func(echo zmq.Socket) error {
+				hbSocket.RunWithSocket(func(echo zmq4.Socket) error {
 					if v.Err != nil {
 						log.Fatalf("Error reading heartbeat ping bytes: %v\n", v.Err)
 						return v.Err

kernel_test.go

@@ -11,7 +11,7 @@ import (
 	"testing"
 	"time"
 
-	zmq "github.com/go-zeromq/zmq4"
+	"github.com/go-zeromq/zmq4"
 )
 
 const (
@@ -327,8 +327,8 @@ cases:
 
 // testJupyterClient holds references to the 2 sockets it uses to communicate with the kernel.
 type testJupyterClient struct {
-	shellSocket zmq.Socket
-	ioSocket    zmq.Socket
+	shellSocket zmq4.Socket
+	ioSocket    zmq4.Socket
 }
 
 // newTestJupyterClient creates and connects a fresh client to the kernel. Upon error, newTestJupyterClient
@@ -344,18 +344,18 @@ func newTestJupyterClient(t *testing.T) (testJupyterClient, func()) {
 	)
 
 	// Prepare the shell socket.
-	shell := zmq.NewReq(ctx)
+	shell := zmq4.NewReq(ctx)
 	if err = shell.Dial(addrShell); err != nil {
 		t.Fatalf("\t%s shell.Connect: %s", failure, err)
 	}
 
 	// Prepare the IOPub socket.
-	iopub := zmq.NewSub(ctx)
+	iopub := zmq4.NewSub(ctx)
 	if err = iopub.Dial(addrIO); err != nil {
 		t.Fatalf("\t%s iopub.Connect: %s", failure, err)
 	}
 
-	if err = iopub.SetOption(zmq.OptionSubscribe, ""); err != nil {
+	if err = iopub.SetOption(zmq4.OptionSubscribe, ""); err != nil {
 		t.Fatalf("\t%s iopub.SetSubscribe: %s", failure, err)
 	}
 
@@ -390,7 +390,7 @@ func (client *testJupyterClient) sendShellRequest(t *testing.T, request Composed
 	}
 	frames = append(frames, reqMsgParts...)
 
-	if err = client.shellSocket.SendMulti(zmq.NewMsgFrom(frames...)); err != nil {
+	if err = client.shellSocket.SendMulti(zmq4.NewMsgFrom(frames...)); err != nil {
 		t.Fatalf("\t%s shellSocket.SendMessage: %s", failure, err)
 	}
 }

messages.go

@@ -7,7 +7,7 @@ import (
 	"encoding/json"
 	"time"
 
-	zmq "github.com/go-zeromq/zmq4"
+	"github.com/go-zeromq/zmq4"
 	"github.com/gofrs/uuid"
 )
 
@@ -139,7 +139,7 @@ func (msg ComposedMsg) ToWireMsg(signkey []byte) ([][]byte, error) {
 }
 
 // SendResponse sends a message back to return identities of the received message.
-func (receipt *msgReceipt) SendResponse(socket zmq.Socket, msg ComposedMsg) error {
+func (receipt *msgReceipt) SendResponse(socket zmq4.Socket, msg ComposedMsg) error {
 
 	msgParts, err := msg.ToWireMsg(receipt.Sockets.Key)
 	if err != nil {
@@ -151,7 +151,7 @@ func (receipt *msgReceipt) SendResponse(socket zmq.Socket, msg ComposedMsg) erro
 	frames = append(frames, []byte("<IDS|MSG>"))
 	frames = append(frames, msgParts...)
 
-	err = socket.SendMulti(zmq.NewMsgFrom(frames...))
+	err = socket.SendMulti(zmq4.NewMsgFrom(frames...))
 	if err != nil {
 		return err
 	}
@@ -190,7 +190,7 @@ func (receipt *msgReceipt) Publish(msgType string, content interface{}) error {
 	}
 
 	msg.Content = content
-	return receipt.Sockets.IOPubSocket.RunWithSocket(func(iopub zmq.Socket) error {
+	return receipt.Sockets.IOPubSocket.RunWithSocket(func(iopub zmq4.Socket) error {
 		return receipt.SendResponse(iopub, msg)
 	})
 }
@@ -205,7 +205,7 @@ func (receipt *msgReceipt) Reply(msgType string, content interface{}) error {
 	}
 
 	msg.Content = content
-	return receipt.Sockets.ShellSocket.RunWithSocket(func(shell zmq.Socket) error {
+	return receipt.Sockets.ShellSocket.RunWithSocket(func(shell zmq4.Socket) error {
 		return receipt.SendResponse(shell, msg)
 	})
 }