import "github.com/zeromq/goczmq"
Package goczmq is a golang binding for CZMQ 3. CZMQ is a high level binding for ZeroMQ. Along with ZeroMQ socket support, CZMQ provides "actor" based services for authentication, service discovery, and creating proxies. GoCZMQ provides direct bindings to CZMQ along with higher level go abstractions such as channels and io.ReadWriter interface support.
"Tell them I was a writer.
A maker of software. A humanist. A father. And many things. But above all, a writer. Thank You. :) - Pieter Hintjens
go:generate gsl sockopts.xml
auth.go beacon.go cert.go certstore.go channeler.go goczmq.go monitor.go poller.go proxy.go readwriter.go sock.go sock_option.go test_utils.go
const (
// Req is a ZMQ_REQ socket type
Req = int(C.ZMQ_REQ)
// Rep is a ZMQ_REP socket type
Rep = int(C.ZMQ_REP)
// Dealer is a ZMQ_DEALER socket type
Dealer = int(C.ZMQ_DEALER)
// Router is a ZMQ_ROUTER socket type
Router = int(C.ZMQ_ROUTER)
// Pub is a ZMQ_PUB socket type
Pub = int(C.ZMQ_PUB)
// Sub is a ZMQ_SUB socket type
Sub = int(C.ZMQ_SUB)
// XPub is a ZMQ_XPUB socket type
XPub = int(C.ZMQ_XPUB)
// XSub is a ZMQ_XSUB socket type
XSub = int(C.ZMQ_XSUB)
// Push is a ZMQ_PUSH socket type
Push = int(C.ZMQ_PUSH)
// Pull is a ZMQ_PULL socket type
Pull = int(C.ZMQ_PULL)
// Pair is a ZMQ_PAIR socket type
Pair = int(C.ZMQ_PAIR)
// Stream is a ZMQ_STREAM socket type
Stream = int(C.ZMQ_STREAM)
// Pollin is the ZMQ_POLLIN constant
Pollin = int(C.ZMQ_POLLIN)
// Pollout is the ZMQ_POLLOUT constant
Pollout = int(C.ZMQ_POLLOUT)
// FlagMore is the ZFRAME_MORE flag
FlagMore = int(C.ZFRAME_MORE)
// FlagReuse is the ZFRAME_REUSE flag
FlagReuse = int(C.ZFRAME_REUSE)
//FlagDontWait is the ZFRAME_DONTWAIT flag
FlagDontWait = int(C.ZFRAME_DONTWAIT)
//FlagNone means there are no flags
FlagNone = 0
// CurveAllowAny is a semantic convenience for allowing
// any Curve clients
CurveAllowAny = "*"
//ZMQVersionMajor is the major version of the underlying ZeroMQ library
ZMQVersionMajor = int(C.ZMQ_VERSION_MAJOR)
//ZMQVersionMinor is the minor version of the underlying ZeroMQ library
ZMQVersionMinor = int(C.ZMQ_VERSION_MINOR)
//CZMQVersionMajor is the major version of the underlying CZMQ library
CZMQVersionMajor = int(C.CZMQ_VERSION_MAJOR)
// CZMQVersionMinor is the minor version of the underlying CZMQ library
CZMQVersionMinor = int(C.CZMQ_VERSION_MINOR)
)var (
// ErrActorCmd is returned when there is an error sending
// a command to an actor
ErrActorCmd = errors.New("error sending actor command")
// ErrSockAttach is returned when an attach call to a socket fails
ErrSockAttach = errors.New("error attaching zsock")
// ErrSockAttachEmptyEndpoints is returned when the endpoints value is empty
ErrSockAttachEmptyEndpoints = errors.New("Endpoints cannot be empty")
// ErrInvalidSockType is returned when a function is called
// against a socket type that is not applicable for that socket type
ErrInvalidSockType = errors.New("invalid socket type")
// ErrSliceFull is returned if a []byte passed to Read was not
// large enough to hold the contents of a message
ErrSliceFull = errors.New("slice full")
// ErrConnect is returned if Connect on a socket fails
ErrConnect = errors.New("connect error")
// ErrDisconnect is returned if Disconnect on a socket fails
ErrDisconnect = errors.New("disconnect error")
// ErrBind is returned if Bind on a socket fails
ErrBind = errors.New("bind error")
// ErrUnbind is returned if Unbind on a socket fails
ErrUnbind = errors.New("unbind error")
// ErrSendFrame is returned if SendFrame on a socket fails
ErrSendFrame = errors.New("send frame error")
// ErrRecvFrame is returned if RecvFrame on a socket fails
ErrRecvFrame = errors.New("recv frame error")
// ErrRecvFrameAfterDestroy is returned if RecvFrame is called
// on a socket after it has been destroyed.
ErrRecvFrameAfterDestroy = errors.New("RecvFrame() is invalid on socket after Detroy() has been called.")
// ErrRecvMessage is returned if RecvMessage on a socket fails
ErrRecvMessage = errors.New("recv message error")
// ErrWaitAfterDestroy is returned by a Poller if there is an error
// accessing the underlying socket pointer when Wait is called
ErrWaitAfterDestroy = errors.New("Wait() is invalid on Poller after Destroy() is called.")
// ErrMultiPartUnsupported is returned when a function that does
// not support multi-part messages encounters a multi-part message
ErrMultiPartUnsupported = errors.New("function does not support multi part messages")
// ErrTimeout is returned when a function that supports timeouts times out
ErrTimeout = errors.New("function timed out")
// ErrCertNotFound is returned when NewCertFromFile tries to
// load a file that does not exist.
ErrCertNotFound = errors.New("file not found")
)Affinity returns the current value of the socket's affinity option
Backlog returns the current value of the socket's backlog option
ConnectTimeout returns the current value of the socket's connect_timeout option
CurvePublickey returns the current value of the socket's curve_publickey option
CurveSecretkey returns the current value of the socket's curve_secretkey option
CurveServer returns the current value of the socket's curve_server option
CurveServerkey returns the current value of the socket's curve_serverkey option
Events returns the current value of the socket's events option
Fd returns the current value of the socket's fd option
GssapiPlaintext returns the current value of the socket's gssapi_plaintext option
GssapiPrincipal returns the current value of the socket's gssapi_principal option
GssapiServer returns the current value of the socket's gssapi_server option
GssapiServicePrincipal returns the current value of the socket's gssapi_service_principal option
HandshakeIvl returns the current value of the socket's handshake_ivl option
HeartbeatIvl returns the current value of the socket's heartbeat_ivl option
HeartbeatTimeout returns the current value of the socket's heartbeat_timeout option
HeartbeatTtl returns the current value of the socket's heartbeat_ttl option
Identity returns the current value of the socket's identity option
Immediate returns the current value of the socket's immediate option
InvertMatching returns the current value of the socket's invert_matching option
Ipv4only returns the current value of the socket's ipv4only option
Ipv6 returns the current value of the socket's ipv6 option
LastEndpoint returns the current value of the socket's last_endpoint option
Linger returns the current value of the socket's linger option
Maxmsgsize returns the current value of the socket's maxmsgsize option
Mechanism returns the current value of the socket's mechanism option
MulticastHops returns the current value of the socket's multicast_hops option
MulticastMaxtpdu returns the current value of the socket's multicast_maxtpdu option
PlainPassword returns the current value of the socket's plain_password option
PlainServer returns the current value of the socket's plain_server option
PlainUsername returns the current value of the socket's plain_username option
Rate returns the current value of the socket's rate option
Rcvbuf returns the current value of the socket's rcvbuf option
Rcvhwm returns the current value of the socket's rcvhwm option
Rcvmore returns the current value of the socket's rcvmore option
Rcvtimeo returns the current value of the socket's rcvtimeo option
ReconnectIvl returns the current value of the socket's reconnect_ivl option
ReconnectIvlMax returns the current value of the socket's reconnect_ivl_max option
RecoveryIvl returns the current value of the socket's recovery_ivl option
func Shutdown()
Shutdown shuts down the CZMQ zsys layer. The CZMQ zsys layer normally shuts down on process termination through the use of an atexit cleanup function. Calling this allows the zsys layer to be shutdown manually.
This is beneficial when CZMQ will no longer be used but the process will not be terminating. Any potential resources allocated by the zsys layer can be freed as they will no longer be needed.
Sndbuf returns the current value of the socket's sndbuf option
Sndhwm returns the current value of the socket's sndhwm option
Sndtimeo returns the current value of the socket's sndtimeo option
SocksProxy returns the current value of the socket's socks_proxy option
TcpAcceptFilter returns the current value of the socket's tcp_accept_filter option
TcpKeepalive returns the current value of the socket's tcp_keepalive option
TcpKeepaliveCnt returns the current value of the socket's tcp_keepalive_cnt option
TcpKeepaliveIdle returns the current value of the socket's tcp_keepalive_idle option
TcpKeepaliveIntvl returns the current value of the socket's tcp_keepalive_intvl option
TcpMaxrt returns the current value of the socket's tcp_maxrt option
ThreadSafe returns the current value of the socket's thread_safe option
Tos returns the current value of the socket's tos option
Type returns the current value of the socket's type option
UseFd returns the current value of the socket's use_fd option
VmciBufferMaxSize returns the current value of the socket's vmci_buffer_max_size option
VmciBufferMinSize returns the current value of the socket's vmci_buffer_min_size option
VmciBufferSize returns the current value of the socket's vmci_buffer_size option
VmciConnectTimeout returns the current value of the socket's vmci_connect_timeout option
ZapDomain returns the current value of the socket's zap_domain option
type Auth struct {
// contains filtered or unexported fields
}Auth wraps the CZMQ zauth actor. It handles authentication for all incoming connections. It allows whitelisting and blackisting peers based on IP address and support PLAIN and CURVE authentication policies.
Code:
// create a server certificate serverCert := NewCert() defer serverCert.Destroy() // create a client certificate and save it clientCert := NewCert() defer clientCert.Destroy() err := clientCert.SavePublic("client_cert") if err != nil { panic(err) } defer func() { err := os.Remove("client_cert") if err != nil { if err != nil { panic(err) } } }() // create an auth service auth := NewAuth() defer auth.Destroy() // tell the auth service the client cert is allowed err = auth.Curve("client_cert") if err != nil { panic(err) } // create a server socket and set it to // use the "global" auth domain server := NewSock(Push, SockSetZapDomain("global")) defer server.Destroy() // set the server cert as the server cert // for the socket we created and set it // to be a curve server serverCert.Apply(server) server.SetOption(SockSetCurveServer(1)) // bind our server to an endpoint _, err = server.Bind("tcp://*:9898") if err != nil { panic(err) } // create a client socket client := NewSock(Pull) defer client.Destroy() // assign the client cert we made to the client clientCert.Apply(client) // set the server cert as the server cert // for the client. for the client to be // allowed to connect, it needs to know // the servers public cert. client.SetOption(SockSetCurveServerkey(serverCert.PublicText())) // connect err = client.Connect("tcp://127.0.0.1:9898") if err != nil { panic(err) }
NewAuth creates a new Auth actor.
Allow removes a previous Deny
Curve sets auth method to curve
Deny adds an address to a socket's deny list
Destroy destroys the auth actor.
Plain sets auth method to plain
Verbose sets the auth actor to log information to stdout.
type Beacon struct {
// contains filtered or unexported fields
}Beacon wraps the CZMQ beacon actor. It implements a peer-to-peer discovery service for local networks. Beacons can broadcast and receive UDPv4 service broadcasts.
Code:
beacon := NewBeacon()
defer beacon.Destroy()
address, err := beacon.Configure(9999)
if err != nil {
panic(err)
}
fmt.Printf("started beacon on: %s", address)
err = beacon.Publish("HI", 100)
if err != nil {
panic(err)
}
NewBeacon creates a new Beacon instance.
Configure accepts a port number and configures the beacon, returning an address
Destroy destroys the beacon.
Publish publishes an announcement string at an interval
PublishBytes publishes an announcement byte slice at an interval
Recv waits for the specific timeout in milliseconds to receive a beacon
Subscribe subscribes to beacons matching the filter
Verbose sets the beacon to log information to stdout.
type Cert struct {
// contains filtered or unexported fields
}Cert wraps the CZMQ zcert class. It provides tools for creating and working with ZMQ CURVE security certs. The certs can be used as a temporary object in memory or persisted to disk. Certs are made up of a public and secret keypair + metadata.
Code:
cert := NewCert()
defer cert.Destroy()
cert.SetMeta("email", "taotetek@gmail.com")
cert.SetMeta("name", "Brian Knox")
cert.SetMeta("organization", "ZeroMQ")
NewCert creates a new empty Cert instance
NewCertFromFile Load loads a Cert from files
NewCertFromKeys creates a new Cert from a public and private key
Apply sets the public and private keys for a socket
Destroy destroys Cert instance
Dup duplicates a Cert
Equal checks two Certs for equality
Meta returns a meta data item from a Cert given a key
Print prints a Cert to stdout
PublicText returns the public key as a string
Save saves the public and secret key to filename and filename_secret
SavePublic saves the public key to a file
SaveSecret saves the secret key to a file
SetMeta sets meta data for a Cert
type CertStore struct {
// contains filtered or unexported fields
}NewCertStore creates a new certificate store from a disk directory, loading and indexing all certificates.
Destroy destroys Cert instance
Insert inserts a certificate into the store in memory. Call Save directly on the cert if you wish to save it to disk.
Lookup looks up a certificate in the store by public key and returns it.
Print prints a list of certificates in the store to stdout
type Channeler struct {
SendChan chan<- [][]byte
RecvChan <-chan [][]byte
ErrChan <-chan error
// contains filtered or unexported fields
}Channeler serializes all access to a socket through a send and receive channel. It starts two threads, one is used for receiving from the zeromq socket. The other is used to listen to the receive channel, and send everything back to the socket thread for sending using an additional inproc socket.
Code:
// create a dealer channeler dealer := NewDealerChanneler("inproc://channelerdealerrouter") defer dealer.Destroy() // create a router channeler router := NewRouterChanneler("inproc://channelerdealerrouter") defer router.Destroy() // send a hello message dealer.SendChan <- [][]byte{[]byte("Hello")} // receive the hello message request := <-router.RecvChan // first frame is identity of client - let's append 'World' // to the message and route it back request = append(request, []byte("World")) // send the reply router.SendChan <- request // receive the reply reply := <-dealer.RecvChan fmt.Printf("%s %s", string(reply[0]), string(reply[1]))
Output:
Hello World
func NewDealerChanneler(endpoints string, options ...SockOption) *Channeler
NewDealerChanneler creates a new Channeler wrapping a Dealer socket. The socket will connect by default.
func NewPairChanneler(endpoints string, options ...SockOption) *Channeler
NewPairChanneler creates a new Channeler wrapping a Pair socket. The socket will connect by default.
func NewPubChanneler(endpoints string, options ...SockOption) *Channeler
NewPubChanneler creats a new Channeler wrapping a Pub socket. The socket will bind by default.
func NewPullChanneler(endpoints string, options ...SockOption) *Channeler
NewPullChanneler creates a new Channeler wrapping a Pull socket. The socket will bind by default.
func NewPushChanneler(endpoints string, options ...SockOption) *Channeler
NewPushChanneler creates a new Channeler wrapping a Push socket. The socket will connect by default.
func NewRepChanneler(endpoints string, options ...SockOption) *Channeler
NewRepChanneler creates a new Channeler wrapping a Rep socket. The socket will bind by default.
func NewReqChanneler(endpoints string, options ...SockOption) *Channeler
NewReqChanneler creates a new Channeler wrapping a Req socket. The socket will connect by default.
func NewRouterChanneler(endpoints string, options ...SockOption) *Channeler
NewRouterChanneler creates a new Channeler wrapping a Router socket. The socket will Bind by default.
func NewStreamChanneler(endpoints string, options ...SockOption) *Channeler
NewStreamChanneler creates a new Channeler wrapping a Pair socket. The socket will connect by default.
NewSubChanneler creates a new Channeler wrapping a Sub socket. Along with an endpoint list it accepts a list of topics and/or socket options (discriminated by type). The socket will connect by default.
func NewXPubChanneler(endpoints string, options ...SockOption) *Channeler
NewXPubChanneler creates a new Channeler wrapping an XPub socket. The socket will Bind by default.
func NewXSubChanneler(endpoints string, options ...SockOption) *Channeler
NewXSubChanneler creates a new Channeler wrapping a XSub socket. The socket will connect by default.
Destroy sends a message to the Channeler to shut it down and clean it up.
Subscribe to a Topic
Unsubscribe from a Topic
type Monitor struct {
// contains filtered or unexported fields
}Monitor provides an API for obtaining socket events
NewMonitor creates new Monitor actor.
Destroy destroys the monitor instance
Listen specifies which events to listen for. "ALL" is also supported.
Socket returns the actor as a Sock instance, useful and necessary for being able to receive messages
Start activates the socket monitoring. Additional Listen() calls will not have an effect after this.
Verbose enables verbose mode, logging activity to stdout
type Poller struct {
// contains filtered or unexported fields
}Poller provides a simple wrapper to ZeroMQ's zmq_poll API, for the common case of reading from a number of sockets. Sockets can be added and removed from the running poller.
Code:
sock1, err := NewRouter("inproc://poller_example_1")
if err != nil {
panic(err)
}
defer sock1.Destroy()
poller, err := NewPoller(sock1)
if err != nil {
panic(err)
}
sock2, err := NewRouter("inproc://poller_example_2")
if err != nil {
panic(err)
}
defer sock2.Destroy()
err = poller.Add(sock2)
if err != nil {
panic(err)
}
// Poller.Wait(millis) returns first socket that has a waiting message
poller.Wait(1)
NewPoller creates a new Poller instance. It accepts one or more readers to poll.
Add adds a reader to be polled.
Destroy destroys the Poller
Remove removes a Sock from the poller
Wait waits for the timeout period in milliseconds for a Pollin event, and returns the first socket that returns one
type Proxy struct {
// contains filtered or unexported fields
}Proxy wraps the CZMQ zproxy actor. A proxy actor switches messages between a frontend and backend socket, and also provides an optional capture socket messages can be mirrored to. The proxy can be paused and resumed.
Code:
proxy := NewProxy() defer proxy.Destroy() // set front end address and socket type err := proxy.SetFrontend(Pull, "inproc://frontend") if err != nil { panic(err) } // set back end address and socket type err = proxy.SetBackend(Push, "inproc://backend") if err != nil { panic(err) } // set address for "tee"ing proxy traffic to err = proxy.SetCapture("inproc://capture") if err != nil { panic(err) } // we can pause the proxy err = proxy.Pause() if err != nil { panic(err) } // and we can resume it err = proxy.Resume() if err != nil { panic(err) } proxy.Destroy()
NewProxy creates a new Proxy instance.
Destroy destroys the proxy.
Pause sends a message to the zproxy actor telling it to pause.
Resume sends a message to the zproxy actor telling it to resume.
SetBackend accepts a socket type and endpoint, and sends a message to the zactor thread telling it to set up a socket bound to the endpoint.
SetBackendCurve accepts Z85 encoded public and secret keys and sends a message to the zactor thread telling it to set up CURVE authentication for the socket.
SetBackendDomain accepts a domain, and sends a message to the zactor thread telling it to set up ZAP authentication domain for the socket.
SetCapture accepts a socket endpoint and sets up a Push socket bound to that endpoint, that sends a copy of all messages passing through the proxy.
SetFrontend accepts a socket type and endpoint, and sends a message to the zactor thread telling it to set up a socket bound to the endpoint.
SetFrontendCurve accepts Z85 encoded public and secret keys and sends a message to the zactor thread telling it to set up CURVE authentication for the socket.
SetFrontendDomain accepts a domain, and sends a message to the zactor thread telling it to set up ZAP authentication domain for the socket.
Verbose sets the proxy to log information to stdout.
type ReadWriter struct {
// contains filtered or unexported fields
}ReadWriter provides an io.ReadWriter compatible interface for goczmq.Sock
func NewReadWriter(sock *Sock) (*ReadWriter, error)
NewReadWriter accepts a sock and returns a goczmq.ReadWriter. The io.ReadWriter should now be considered responsible for this Sock.
func (r *ReadWriter) Destroy()
Destroy destroys both the ReadWriter and the underlying Sock
func (r *ReadWriter) GetLastClientID() []byte
GetLastClientID returns the id of the last client you received a message from if the underlying socket is a Router socket
func (r *ReadWriter) Read(p []byte) (int, error)
Read satisifies io.Read
func (r *ReadWriter) SetLastClientID(id []byte)
SetLastClientID lets you manually set the id of the client you last received a message from if the underlying socket is a Router socket
func (r *ReadWriter) SetTimeout(ms int)
SetTimeout sets the timeout on Read in millisecond. If no new data is received within the timeout period, Read will return an ErrTimeout
func (r *ReadWriter) Write(p []byte) (int, error)
Write satisfies io.Write
type Sock struct {
// contains filtered or unexported fields
}Sock wraps the CZMQ zsock class.
Code:
package main
import (
"encoding/gob"
"fmt"
"testing"
)
func TestSendFrame(t *testing.T) {
pushSock := NewSock(Push)
defer pushSock.Destroy()
pullSock := NewSock(Pull)
defer pullSock.Destroy()
_, err := pullSock.Bind("inproc://test-send-frame")
if err != nil {
t.Error(err)
}
err = pushSock.Connect("inproc://test-send-frame")
if err != nil {
t.Error(err)
}
err = pushSock.SendFrame([]byte("Hello"), FlagNone)
if err != nil {
t.Error(err)
}
frame, _, err := pullSock.RecvFrame()
if err != nil {
t.Error(err)
}
if want, have := "Hello", string(frame); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
_, flag, err := pullSock.RecvFrameNoWait()
if err == nil {
t.Error(err)
}
if want, have := true, flag == 0; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
err = pushSock.SendFrame([]byte("World"), FlagNone)
if err != nil {
t.Error(err)
}
_, flag, err = pullSock.RecvFrameNoWait()
if err != nil {
t.Error(err)
}
if want, have := true, flag == 0; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
err = pushSock.SendFrame([]byte("World"), FlagNone)
if err != nil {
t.Error(err)
}
}
func TestSendEmptyFrame(t *testing.T) {
pushSock := NewSock(Push)
defer pushSock.Destroy()
pullSock := NewSock(Pull)
defer pullSock.Destroy()
_, err := pullSock.Bind("inproc://test-send-empty")
if err != nil {
t.Error(err)
}
err = pushSock.Connect("inproc://test-send-empty")
if err != nil {
t.Error(err)
}
var empty []byte
err = pushSock.SendFrame(empty, FlagNone)
if err != nil {
t.Error(err)
}
frame, _, err := pullSock.RecvFrame()
if err != nil {
t.Error(err)
}
if want, have := 0, len(frame); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestSendMessage(t *testing.T) {
pushSock := NewSock(Push)
defer pushSock.Destroy()
pullSock := NewSock(Pull)
defer pullSock.Destroy()
_, err := pullSock.Bind("inproc://test-send-msg")
if err != nil {
t.Error(err)
}
err = pushSock.Connect("inproc://test-send-msg")
if err != nil {
t.Error(err)
}
err = pushSock.SendMessage([][]byte{[]byte("Hello")})
if err != nil {
t.Error(err)
}
msg, err := pullSock.RecvMessage()
if err != nil {
t.Error(err)
}
if want, have := "Hello", string(msg[0]); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
_, err = pullSock.RecvMessageNoWait()
if err == nil {
t.Error(err)
}
err = pushSock.SendMessage([][]byte{[]byte("World")})
if err != nil {
t.Error(err)
}
msg, err = pullSock.RecvMessageNoWait()
if err != nil {
t.Error(err)
}
if want, have := "World", string(msg[0]); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestPubSub(t *testing.T) {
bogusPub, err := NewPub("bogus://bogus")
if err == nil {
t.Error(err)
}
defer bogusPub.Destroy()
bogusSub, err := NewSub("bogus://bogus", "")
if err == nil {
t.Error(err)
}
defer bogusSub.Destroy()
pub, err := NewPub("inproc://pub1,inproc://pub2")
if err != nil {
t.Error(err)
}
defer pub.Destroy()
sub, err := NewSub("inproc://pub1,inproc://pub2", "")
if err != nil {
t.Error(err)
}
defer sub.Destroy()
err = pub.SendFrame([]byte("test pub sub"), FlagNone)
if err != nil {
t.Error(err)
}
frame, _, err := sub.RecvFrame()
if err != nil {
t.Error(err)
}
if want, have := "test pub sub", string(frame); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestReqRep(t *testing.T) {
bogusReq, err := NewReq("bogus://bogus")
if err == nil {
t.Error(err)
}
defer bogusReq.Destroy()
bogusRep, err := NewRep("bogus://bogus")
if err == nil {
t.Error(err)
}
defer bogusRep.Destroy()
rep, err := NewRep("inproc://rep1,inproc://rep2")
if err != nil {
t.Error(err)
}
defer rep.Destroy()
req, err := NewReq("inproc://rep1,inproc://rep2")
if err != nil {
t.Error(err)
}
defer req.Destroy()
err = req.SendFrame([]byte("Hello"), FlagNone)
if err != nil {
t.Error(err)
}
reqframe, _, err := rep.RecvFrame()
if err != nil {
t.Error(err)
}
if want, have := "Hello", string(reqframe); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
err = rep.SendFrame([]byte("World"), FlagNone)
if err != nil {
t.Error(err)
}
repframe, _, err := req.RecvFrame()
if err != nil {
t.Error(err)
}
if want, have := "World", string(repframe); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestPushPull(t *testing.T) {
bogusPush, err := NewPush("bogus://bogus")
if err == nil {
t.Error(err)
}
defer bogusPush.Destroy()
bogusPull, err := NewPull("bogus://bogus")
if err == nil {
t.Error(err)
}
defer bogusPull.Destroy()
push, err := NewPush("inproc://push1,inproc://push2")
if err != nil {
t.Error(err)
}
defer push.Destroy()
pull, err := NewPull("inproc://push1,inproc://push2")
if err != nil {
t.Error(err)
}
defer pull.Destroy()
err = push.SendFrame([]byte("Hello"), FlagMore)
if err != nil {
t.Error(err)
}
err = push.SendFrame([]byte("World"), FlagNone)
if err != nil {
t.Error(err)
}
msg, err := pull.RecvMessage()
if err != nil {
t.Error(err)
}
if want, have := "Hello", string(msg[0]); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := "World", string(msg[1]); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestRouterDealer(t *testing.T) {
bogusDealer, err := NewDealer("bogus://bogus")
if err == nil {
t.Error(err)
}
defer bogusDealer.Destroy()
bogusRouter, err := NewRouter("bogus://bogus")
if err == nil {
t.Error(err)
}
defer bogusRouter.Destroy()
dealer, err := NewDealer("inproc://router1,inproc://router2")
if err != nil {
t.Error(err)
}
defer dealer.Destroy()
router, err := NewRouter("inproc://router1,inproc://router2")
if err != nil {
t.Error(err)
}
defer router.Destroy()
err = dealer.SendFrame([]byte("Hello"), FlagNone)
if err != nil {
t.Error(err)
}
msg, err := router.RecvMessage()
if err != nil {
t.Error(err)
}
if want, have := 2, len(msg); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := "Hello", string(msg[1]); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
msg[1] = []byte("World")
err = router.SendMessage(msg)
if err != nil {
t.Error(err)
}
msg, err = dealer.RecvMessage()
if err != nil {
t.Error(err)
}
if want, have := 1, len(msg); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := "World", string(msg[0]); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestXSubXPub(t *testing.T) {
bogusXPub, err := NewXPub("bogus://bogus")
if err == nil {
t.Error("NewXPub should have returned error and did not")
}
defer bogusXPub.Destroy()
bogusXSub, err := NewXSub("bogus://bogus")
if err == nil {
t.Error(err)
}
defer bogusXSub.Destroy()
xpub, err := NewXPub("inproc://xpub1,inproc://xpub2")
if err != nil {
t.Error(err)
}
defer xpub.Destroy()
xsub, err := NewXSub("inproc://xpub1,inproc://xpub2")
if err != nil {
t.Error(err)
}
defer xsub.Destroy()
}
func TestPair(t *testing.T) {
bogusPair, err := NewPair("bogus://bogus")
if err == nil {
t.Error(err)
}
defer bogusPair.Destroy()
pair1, err := NewPair(">inproc://pair")
if err != nil {
t.Error(err)
}
defer pair1.Destroy()
pair2, err := NewPair("@inproc://pair")
if err != nil {
t.Error(err)
}
defer pair2.Destroy()
}
func TestStream(t *testing.T) {
bogusStream, err := NewStream("bogus://bogus")
if err == nil {
t.Error(err)
}
defer bogusStream.Destroy()
stream1, err := NewStream(">inproc://stream")
if err != nil {
t.Error(err)
}
defer stream1.Destroy()
stream2, err := NewStream("@inproc://stream")
if err != nil {
t.Error(err)
}
defer stream2.Destroy()
}
func TestPollin(t *testing.T) {
push, err := NewPush("inproc://pollin")
if err != nil {
t.Error(err)
}
defer push.Destroy()
pull, err := NewPull("inproc://pollin")
if err != nil {
t.Error(err)
}
defer pull.Destroy()
if want, have := false, pull.Pollin(); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
err = push.SendFrame([]byte("Hello World"), FlagNone)
if err != nil {
t.Error(err)
}
if want, have := true, pull.Pollin(); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestPollinPolloutRouter(t *testing.T) {
router, err := NewRouter("inproc://router")
if err != nil {
t.Error(err)
}
defer router.Destroy()
dealer, err := NewDealer("inproc://router")
if err != nil {
t.Error(err)
}
defer dealer.Destroy()
// for Router pollout is always true
if want, have := true, router.Pollout(); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := false, router.Pollin(); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
err = dealer.SendFrame([]byte("Hello World"), FlagNone)
if err != nil {
t.Error(err)
}
if want, have := true, router.Pollin(); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := true, router.Pollout(); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestPollout(t *testing.T) {
push := NewSock(Push)
_, err := push.Bind("inproc://pollout")
if err != nil {
t.Error(err)
}
defer push.Destroy()
if want, have := false, push.Pollout(); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
pull := NewSock(Pull)
defer pull.Destroy()
err = pull.Connect("inproc://pollout")
if err != nil {
t.Error(err)
}
if want, have := true, push.Pollout(); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestReader(t *testing.T) {
pushSock := NewSock(Push)
defer pushSock.Destroy()
pullSock := NewSock(Pull)
defer pullSock.Destroy()
_, err := pullSock.Bind("inproc://test-read")
if err != nil {
t.Error(err)
}
err = pushSock.Connect("inproc://test-read")
if err != nil {
t.Error(err)
}
err = pushSock.SendFrame([]byte("Hello"), FlagNone)
if err != nil {
t.Error(err)
}
b := make([]byte, 5)
n, err := pullSock.Read(b)
if want, have := 5, n; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if err != nil {
t.Error(err)
}
if want, have := "Hello", string(b); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
err = pushSock.SendFrame([]byte("Hello"), FlagMore)
if err != nil {
t.Error(err)
}
err = pushSock.SendFrame([]byte(" World"), FlagNone)
if err != nil {
t.Error(err)
}
b = make([]byte, 8)
_, err = pullSock.Read(b)
if want, have := ErrSliceFull, err; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := "Hello Wo", string(b); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestReaderWithRouterDealer(t *testing.T) {
dealerSock := NewSock(Dealer)
defer dealerSock.Destroy()
routerSock := NewSock(Router)
defer routerSock.Destroy()
_, err := routerSock.Bind("inproc://test-read-router")
if err != nil {
t.Error(err)
}
err = dealerSock.Connect("inproc://test-read-router")
if err != nil {
t.Error(err)
}
err = dealerSock.SendFrame([]byte("Hello"), FlagNone)
if err != nil {
t.Error(err)
}
b := make([]byte, 5)
n, err := routerSock.Read(b)
if err != nil {
t.Error(err)
}
if want, have := 5, n; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := "Hello", string(b); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
err = dealerSock.SendFrame([]byte("Hello"), FlagMore)
if err != nil {
t.Error(err)
}
err = dealerSock.SendFrame([]byte(" World"), FlagNone)
if err != nil {
t.Error(err)
}
b = make([]byte, 8)
_, err = routerSock.Read(b)
if want, have := ErrSliceFull, err; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := "Hello Wo", string(b); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
n, err = routerSock.Write([]byte("World"))
if err != nil {
t.Error(err)
}
if want, have := 5, n; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
frame, _, err := dealerSock.RecvFrame()
if err != nil {
t.Error(err)
}
if want, have := "World", string(frame); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestReaderWithRouterDealerAsync(t *testing.T) {
dealerSock1 := NewSock(Dealer)
defer dealerSock1.Destroy()
dealerSock2 := NewSock(Dealer)
defer dealerSock2.Destroy()
routerSock := NewSock(Router)
defer routerSock.Destroy()
_, err := routerSock.Bind("inproc://test-read-router-async")
if err != nil {
t.Error(err)
}
err = dealerSock1.Connect("inproc://test-read-router-async")
if err != nil {
t.Error(err)
}
err = dealerSock1.SendFrame([]byte("Hello From Client 1!"), FlagNone)
if err != nil {
t.Error(err)
}
err = dealerSock2.Connect("inproc://test-read-router-async")
if err != nil {
t.Error(err)
}
err = dealerSock2.SendFrame([]byte("Hello From Client 2!"), FlagNone)
if err != nil {
t.Error(err)
}
msg := make([]byte, 255)
n, err := routerSock.Read(msg)
if err != nil {
t.Error(err)
}
if want, have := 20, n; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
client1ID := routerSock.GetLastClientID()
if want, have := 20, n; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := "Hello From Client 1!", string(msg[:n]); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
n, err = routerSock.Read(msg)
if err != nil {
t.Error(err)
}
if want, have := 20, n; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
client2ID := routerSock.GetLastClientID()
if want, have := "Hello From Client 2!", string(msg[:n]); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
routerSock.SetLastClientID(client1ID)
_, err = routerSock.Write([]byte("Hello Client 1!"))
if err != nil {
t.Error(err)
}
frame, _, err := dealerSock1.RecvFrame()
if err != nil {
t.Error(err)
}
if want, have := "Hello Client 1!", string(frame); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
routerSock.SetLastClientID(client2ID)
_, err = routerSock.Write([]byte("Hello Client 2!"))
if err != nil {
t.Error(err)
}
frame, _, err = dealerSock2.RecvFrame()
if err != nil {
t.Error(err)
}
if want, have := "Hello Client 2!", string(frame); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
type encodeMessage struct {
Foo string
Bar []byte
Bat int
}
func TestPushPullEncodeDecode(t *testing.T) {
push, err := NewPush("inproc://pushpullencode")
if err != nil {
t.Error(err)
}
defer push.Destroy()
pull, err := NewPull("inproc://pushpullencode")
if err != nil {
t.Error(err)
}
defer pull.Destroy()
encoder := gob.NewEncoder(push)
decoder := gob.NewDecoder(pull)
sent := encodeMessage{
Foo: "the answer",
Bar: []byte("is"),
Bat: 42,
}
err = encoder.Encode(sent)
if err != nil {
t.Error(err)
}
var received encodeMessage
err = decoder.Decode(&received)
if err != nil {
t.Error(err)
}
if want, have := received.Foo, sent.Foo; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := string(received.Bar), string(sent.Bar); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := received.Bat, sent.Bat; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if received.Bat != sent.Bat {
t.Errorf("expected %#v, have %#v", sent.Bat, received.Bat)
}
}
func TestDealerRouterEncodeDecode(t *testing.T) {
router, err := NewRouter("inproc://dealerrouterencode")
if err != nil {
t.Error(err)
}
defer router.Destroy()
dealer, err := NewDealer("inproc://dealerrouterencode")
if err != nil {
t.Error(err)
}
defer dealer.Destroy()
rencoder := gob.NewEncoder(router)
rdecoder := gob.NewDecoder(router)
dencoder := gob.NewEncoder(dealer)
ddecoder := gob.NewDecoder(dealer)
question := encodeMessage{
Foo: "what is",
Bar: []byte("the answer"),
Bat: 0,
}
err = dencoder.Encode(question)
if err != nil {
t.Error(err)
}
var received encodeMessage
err = rdecoder.Decode(&received)
if err != nil {
t.Error(err)
}
if want, have := received.Foo, question.Foo; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := string(received.Bar), string(question.Bar); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := received.Bat, question.Bat; want != have {
t.Errorf("expected %#v, have %#v", want, have)
}
sent := encodeMessage{
Foo: "the answer",
Bar: []byte("is"),
Bat: 42,
}
err = rencoder.Encode(sent)
if err != nil {
t.Error(err)
}
var answer encodeMessage
err = ddecoder.Decode(&answer)
if err != nil {
t.Error(err)
}
if want, have := answer.Foo, sent.Foo; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := string(answer.Bar), string(sent.Bar); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
if want, have := answer.Bat, sent.Bat; want != have {
t.Errorf("want %#v, have %#v", want, have)
}
}
func TestRecvFrameCalledAfterDestroy(t *testing.T) {
rep, err := NewRep("inproc://rep1")
if err != nil {
t.Error(err)
}
req, err := NewReq("inproc://rep1")
if err != nil {
t.Error(err)
}
defer req.Destroy()
err = req.SendFrame([]byte("Hello"), FlagNone)
if err != nil {
t.Error(err)
}
// Just verify that the connection actually works.
reqframe, _, err := rep.RecvFrame()
if err != nil {
t.Error(err)
}
if want, have := "Hello", string(reqframe); want != have {
t.Errorf("want %#v, have %#v", want, have)
}
rep.Destroy()
_, _, err = rep.RecvFrame()
if err != ErrRecvFrameAfterDestroy {
t.Errorf("want %#v, have %#v", ErrRecvFrameAfterDestroy, err)
}
}
func main() {
// create dealer socket
dealer, err := NewDealer("inproc://example")
if err != nil {
panic(err)
}
defer dealer.Destroy()
// create router socket
router, err := NewRouter("inproc://example")
if err != nil {
panic(err)
}
defer router.Destroy()
// send hello message
err = dealer.SendFrame([]byte("Hello"), FlagNone)
if err != nil {
panic(err)
}
// receive hello message
request, err := router.RecvMessage()
if err != nil {
panic(err)
}
// first frame is identify of client - let's append 'World'
// to the message and route it back.
request = append(request, []byte("World"))
// send reply
err = router.SendMessage(request)
if err != nil {
panic(err)
}
// receive reply
reply, err := dealer.RecvMessage()
if err != nil {
panic(err)
}
fmt.Printf("%s %s", string(reply[0]), string(reply[1]))
}
func benchmarkSockSendFrame(size int, b *testing.B) {
pullSock := NewSock(Pull)
defer pullSock.Destroy()
_, err := pullSock.Bind(fmt.Sprintf("inproc://benchSockSendFrame%#v", size))
if err != nil {
panic(err)
}
go func() {
pushSock := NewSock(Push)
defer pushSock.Destroy()
err := pushSock.Connect(fmt.Sprintf("inproc://benchSockSendFrame%#v", size))
if err != nil {
panic(err)
}
payload := make([]byte, size)
for i := 0; i < b.N; i++ {
err = pushSock.SendFrame(payload, FlagNone)
if err != nil {
panic(err)
}
}
}()
for i := 0; i < b.N; i++ {
msg, _, err := pullSock.RecvFrame()
if err != nil {
panic(err)
}
if len(msg) != size {
panic("msg too small")
}
b.SetBytes(int64(size))
}
}
func BenchmarkSockSendFrame1k(b *testing.B) { benchmarkSockSendFrame(1024, b) }
func BenchmarkSockSendFrame4k(b *testing.B) { benchmarkSockSendFrame(4096, b) }
func BenchmarkSockSendFrame16k(b *testing.B) { benchmarkSockSendFrame(16384, b) }
func BenchmarkEncodeDecode(b *testing.B) {
pullSock := NewSock(Pull)
defer pullSock.Destroy()
decoder := gob.NewDecoder(pullSock)
_, err := pullSock.Bind("inproc://benchSockEncodeDecode")
if err != nil {
panic(err)
}
go func() {
pushSock := NewSock(Push)
defer pushSock.Destroy()
err := pushSock.Connect("inproc://benchSockEncodeDecode")
if err != nil {
panic(err)
}
encoder := gob.NewEncoder(pushSock)
sent := encodeMessage{
Foo: "the answer",
Bar: make([]byte, 1024),
Bat: 42,
}
for i := 0; i < b.N; i++ {
err := encoder.Encode(sent)
if err != nil {
panic(err)
}
}
}()
var received encodeMessage
for i := 0; i < b.N; i++ {
err := decoder.Decode(&received)
if err != nil {
panic(err)
}
}
}
func NewDealer(endpoints string, options ...SockOption) (*Sock, error)
NewDealer creates a Dealer socket and calls Attach. The socket will Connect by default.
func NewPair(endpoints string, options ...SockOption) (*Sock, error)
NewPair creates a Pair socket and calls Attach. The socket will Connect by default.
func NewPub(endpoints string, options ...SockOption) (*Sock, error)
NewPub creates a Pub socket and calls Attach. The socket will Bind by default.
func NewPull(endpoints string, options ...SockOption) (*Sock, error)
NewPull creates a Pull socket and calls Attach. The socket will Bind by default.
func NewPush(endpoints string, options ...SockOption) (*Sock, error)
NewPush creates a Push socket and calls Attach. The socket will Connect by default.
func NewRep(endpoints string, options ...SockOption) (*Sock, error)
NewRep creates a Rep socket and calls Attach. The socket will Bind by default.
func NewReq(endpoints string, options ...SockOption) (*Sock, error)
NewReq creates a Req socket and calls Attach. The socket will Connect by default.
func NewRouter(endpoints string, options ...SockOption) (*Sock, error)
NewRouter creates a Router socket and calls Attach. The socket will Bind by default.
func NewSock(t int, options ...SockOption) *Sock
NewSock creates a new socket. The caller source and line number are passed so CZMQ can report socket leaks intelligently.
func NewStream(endpoints string, options ...SockOption) (*Sock, error)
NewStream creates a Stream socket and calls Attach. The socket will Connect by default.
NewSub creates a Sub socket and calls Attach. 'subscribe' is a comma delimited list of topics to subscribe to. The socket will Connect by default.
func NewXPub(endpoints string, options ...SockOption) (*Sock, error)
NewXPub creates an XPub socket and calls Attach. The socket will Bind by default.
func NewXSub(endpoints string, options ...SockOption) (*Sock, error)
NewXSub creates an XSub socket and calls Attach. The socket will Connect by default.
Attach attaches a socket to zero or more endpoints. If endpoints is not null, parses as list of ZeroMQ endpoints, separated by commas, and prefixed by '@' (to bind the socket) or '>' (to attach the socket). If the endpoint does not start with '@' or '>', the serverish argument determines whether it is used to bind (serverish = true) or connect (serverish = false)
Bind binds a socket to an endpoint. On success returns the port number used for tcp transports, or 0 for other transports. On failure returns a -1 for port, and an error.
Connect connects a socket to an endpoint returns an error if the connect failed.
Destroy destroys the underlying zsockT.
Disconnect disconnects a socket from an endpoint. If returns an error if the endpoint was not found
GetLastClientID returns the id of the last client you received a message from if the underlying socket is a Router socket DEPRECATED: See goczmq.ReadWriter
GetType returns the socket's type
Pollin returns true if there is a Pollin event on the socket
Pollout returns true if there is a Pollout event on the socket
Read provides an io.Reader interface to a zeromq socket DEPRECATED: see goczmq.ReadWriter
RecvFrame reads a frame from the socket and returns it as a byte array, along with a more flag and and error (if there is an error)
RecvFrameNoWait receives a frame from the socket and returns it as a byte array if one is waiting. Returns an empty frame, a 0 more flag and an error if one is not immediately available
RecvMessage receives a full message from the socket and returns it as an array of byte arrays.
RecvMessageNoWait receives a full message from the socket and returns it as an array of byte arrays if one is waiting. Returns an empty message and an error if one is not immediately available
SendFrame sends a byte array via the socket. For the flags value, use FlagNone (0) for a single message, or FlagMore if it is a multi-part message
SendMessage accepts an array of byte arrays and sends it as a multi-part message.
SetLastClientID lets you manually set the id of the client you last received a message from if the underlying socket is a Router socket DEPRECATED: See goczmq.ReadWriter
func (s *Sock) SetOption(o SockOption)
SetOption accepts a SockOption and uses it to set an option on the underlying ZeroMQ socket
Unbind unbinds a socket from an endpoint. If returns an error if the endpoint was not found
Write provides an io.Writer interface to a zeromq socket DEPRECATED: See goczmq.ReadWriter
SockOption is a type for setting options on the underlying ZeroMQ socket
func SockSetAffinity(v int) SockOption
SockSetAffinity sets the affinity option for the socket
func SockSetBacklog(v int) SockOption
SockSetBacklog sets the backlog option for the socket
func SockSetConflate(v int) SockOption
SockSetConflate sets the conflate option for the socket
func SockSetConnectRid(v string) SockOption
SockSetConnectRid sets the connect_rid option for the socket
func SockSetConnectTimeout(v int) SockOption
SockSetConnectTimeout sets the connect_timeout option for the socket
func SockSetCurvePublickey(v string) SockOption
SockSetCurvePublickey sets the curve_publickey option for the socket
func SockSetCurveSecretkey(v string) SockOption
SockSetCurveSecretkey sets the curve_secretkey option for the socket
func SockSetCurveServer(v int) SockOption
SockSetCurveServer sets the curve_server option for the socket
func SockSetCurveServerkey(v string) SockOption
SockSetCurveServerkey sets the curve_serverkey option for the socket
func SockSetDelayAttachOnConnect(v int) SockOption
SockSetDelayAttachOnConnect sets the delay_attach_on_connect option for the socket
func SockSetGssapiPlaintext(v int) SockOption
SockSetGssapiPlaintext sets the gssapi_plaintext option for the socket
func SockSetGssapiPrincipal(v string) SockOption
SockSetGssapiPrincipal sets the gssapi_principal option for the socket
func SockSetGssapiServer(v int) SockOption
SockSetGssapiServer sets the gssapi_server option for the socket
func SockSetGssapiServicePrincipal(v string) SockOption
SockSetGssapiServicePrincipal sets the gssapi_service_principal option for the socket
func SockSetHandshakeIvl(v int) SockOption
SockSetHandshakeIvl sets the handshake_ivl option for the socket
func SockSetHeartbeatIvl(v int) SockOption
SockSetHeartbeatIvl sets the heartbeat_ivl option for the socket
func SockSetHeartbeatTimeout(v int) SockOption
SockSetHeartbeatTimeout sets the heartbeat_timeout option for the socket
func SockSetHeartbeatTtl(v int) SockOption
SockSetHeartbeatTtl sets the heartbeat_ttl option for the socket
func SockSetIdentity(v string) SockOption
SockSetIdentity sets the identity option for the socket
func SockSetImmediate(v int) SockOption
SockSetImmediate sets the immediate option for the socket
func SockSetInvertMatching(v int) SockOption
SockSetInvertMatching sets the invert_matching option for the socket
func SockSetIpv4only(v int) SockOption
SockSetIpv4only sets the ipv4only option for the socket
func SockSetIpv6(v int) SockOption
SockSetIpv6 sets the ipv6 option for the socket
func SockSetLinger(v int) SockOption
SockSetLinger sets the linger option for the socket
func SockSetMaxmsgsize(v int) SockOption
SockSetMaxmsgsize sets the maxmsgsize option for the socket
func SockSetMulticastHops(v int) SockOption
SockSetMulticastHops sets the multicast_hops option for the socket
func SockSetMulticastMaxtpdu(v int) SockOption
SockSetMulticastMaxtpdu sets the multicast_maxtpdu option for the socket
func SockSetPlainPassword(v string) SockOption
SockSetPlainPassword sets the plain_password option for the socket
func SockSetPlainServer(v int) SockOption
SockSetPlainServer sets the plain_server option for the socket
func SockSetPlainUsername(v string) SockOption
SockSetPlainUsername sets the plain_username option for the socket
func SockSetProbeRouter(v int) SockOption
SockSetProbeRouter sets the probe_router option for the socket
func SockSetRate(v int) SockOption
SockSetRate sets the rate option for the socket
func SockSetRcvbuf(v int) SockOption
SockSetRcvbuf sets the rcvbuf option for the socket
func SockSetRcvhwm(v int) SockOption
SockSetRcvhwm sets the rcvhwm option for the socket
func SockSetRcvtimeo(v int) SockOption
SockSetRcvtimeo sets the rcvtimeo option for the socket
func SockSetReconnectIvl(v int) SockOption
SockSetReconnectIvl sets the reconnect_ivl option for the socket
func SockSetReconnectIvlMax(v int) SockOption
SockSetReconnectIvlMax sets the reconnect_ivl_max option for the socket
func SockSetRecoveryIvl(v int) SockOption
SockSetRecoveryIvl sets the recovery_ivl option for the socket
func SockSetReqCorrelate(v int) SockOption
SockSetReqCorrelate sets the req_correlate option for the socket
func SockSetReqRelaxed(v int) SockOption
SockSetReqRelaxed sets the req_relaxed option for the socket
func SockSetRouterHandover(v int) SockOption
SockSetRouterHandover sets the router_handover option for the socket
func SockSetRouterMandatory(v int) SockOption
SockSetRouterMandatory sets the router_mandatory option for the socket
func SockSetRouterRaw(v int) SockOption
SockSetRouterRaw sets the router_raw option for the socket
func SockSetSndbuf(v int) SockOption
SockSetSndbuf sets the sndbuf option for the socket
func SockSetSndhwm(v int) SockOption
SockSetSndhwm sets the sndhwm option for the socket
func SockSetSndtimeo(v int) SockOption
SockSetSndtimeo sets the sndtimeo option for the socket
func SockSetSocksProxy(v string) SockOption
SockSetSocksProxy sets the socks_proxy option for the socket
func SockSetStreamNotify(v int) SockOption
SockSetStreamNotify sets the stream_notify option for the socket
func SockSetSubscribe(v string) SockOption
SockSetSubscribe sets the subscribe option for the socket
func SockSetTcpAcceptFilter(v string) SockOption
SockSetTcpAcceptFilter sets the tcp_accept_filter option for the socket
func SockSetTcpKeepalive(v int) SockOption
SockSetTcpKeepalive sets the tcp_keepalive option for the socket
func SockSetTcpKeepaliveCnt(v int) SockOption
SockSetTcpKeepaliveCnt sets the tcp_keepalive_cnt option for the socket
func SockSetTcpKeepaliveIdle(v int) SockOption
SockSetTcpKeepaliveIdle sets the tcp_keepalive_idle option for the socket
func SockSetTcpKeepaliveIntvl(v int) SockOption
SockSetTcpKeepaliveIntvl sets the tcp_keepalive_intvl option for the socket
func SockSetTcpMaxrt(v int) SockOption
SockSetTcpMaxrt sets the tcp_maxrt option for the socket
func SockSetTos(v int) SockOption
SockSetTos sets the tos option for the socket
func SockSetUnsubscribe(v string) SockOption
SockSetUnsubscribe sets the unsubscribe option for the socket
func SockSetUseFd(v int) SockOption
SockSetUseFd sets the use_fd option for the socket
func SockSetVmciBufferMaxSize(v int) SockOption
SockSetVmciBufferMaxSize sets the vmci_buffer_max_size option for the socket
func SockSetVmciBufferMinSize(v int) SockOption
SockSetVmciBufferMinSize sets the vmci_buffer_min_size option for the socket
func SockSetVmciBufferSize(v int) SockOption
SockSetVmciBufferSize sets the vmci_buffer_size option for the socket
func SockSetVmciConnectTimeout(v int) SockOption
SockSetVmciConnectTimeout sets the vmci_connect_timeout option for the socket
func SockSetXPubManual(v int) SockOption
SockSetXPubManual sets the xpub_manual option for the socket
func SockSetXPubNodrop(v int) SockOption
SockSetXPubNodrop sets the xpub_nodrop option for the socket
func SockSetXPubVerbose(v int) SockOption
SockSetXPubVerbose sets the xpub_verbose option for the socket
func SockSetXPubVerboser(v int) SockOption
SockSetXPubVerboser sets the xpub_verboser option for the socket
func SockSetXPubWelcomeMsg(v string) SockOption
SockSetXPubWelcomeMsg sets the xpub_welcome_msg option for the socket
func SockSetZapDomain(v string) SockOption
SockSetZapDomain sets the zap_domain option for the socket
Package goczmq imports 11 packages (graph) and is imported by 7 packages. Updated 2020-10-19. Refresh now. Tools for package owners.