175 lines
3.8 KiB
Markdown
175 lines
3.8 KiB
Markdown
# server.go
|
|
```go
|
|
package main
|
|
|
|
/*
|
|
#cgo pkg-config: libzmq
|
|
#include <zmq.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <malloc.h>
|
|
*/
|
|
import "C"
|
|
// sudo apt-get install libzmq3-dev
|
|
import (
|
|
"unsafe"
|
|
"fmt"
|
|
)
|
|
|
|
func main() {
|
|
context := C.zmq_ctx_new()
|
|
defer C.zmq_ctx_destroy(context)
|
|
|
|
responder := C.zmq_socket(context, C.ZMQ_REP)
|
|
defer C.zmq_close(responder)
|
|
|
|
rc := C.zmq_bind(responder, C.CString("tcp://*:5555"))
|
|
if rc != 0 {
|
|
panic("Failed to bind socket")
|
|
}
|
|
|
|
for {
|
|
buffer := make([]byte, 10)
|
|
C.zmq_recv(responder, unsafe.Pointer(&buffer[0]), 10, 0)
|
|
fmt.Println("Received Hello")
|
|
C.sleep(1)
|
|
message := unsafe.Pointer(C.CString("World"))
|
|
defer C.free(message)
|
|
C.zmq_send(responder, message, 5, 0)
|
|
}
|
|
}
|
|
```
|
|
|
|
# client.go
|
|
```go
|
|
package main
|
|
/*
|
|
#cgo pkg-config: libzmq
|
|
#include <zmq.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
*/
|
|
import "C"
|
|
import (
|
|
"fmt"
|
|
"unsafe"
|
|
)
|
|
|
|
func main(){
|
|
fmt.Println("Connecting to hello world server…")
|
|
|
|
context := C.zmq_ctx_new()
|
|
defer C.zmq_ctx_destroy(context)
|
|
|
|
requester := C.zmq_socket(context, C.ZMQ_REQ)
|
|
defer C.zmq_close(requester)
|
|
|
|
C.zmq_connect(requester, C.CString("tcp://localhost:5555"))
|
|
|
|
// for request_nbr := range 10 {
|
|
|
|
for request_nbr := 0; request_nbr < 10; request_nbr++ {
|
|
buffer := make([]byte, 10)
|
|
fmt.Printf("Sending Hello %d...\n", request_nbr)
|
|
msg := unsafe.Pointer(C.CString("Hello"))
|
|
defer C.free(msg)
|
|
C.zmq_send(requester, msg, 5, 0);
|
|
C.zmq_recv(requester, unsafe.Pointer(&buffer[0]), 10, 0);
|
|
fmt.Printf("Received World %d\n", request_nbr)
|
|
}
|
|
}
|
|
```
|
|
|
|
# multipart
|
|
|
|
```go
|
|
package main
|
|
|
|
/*
|
|
#cgo pkg-config: libzmq
|
|
#include <zmq.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
*/
|
|
import "C"
|
|
import (
|
|
"fmt"
|
|
"unsafe"
|
|
"time"
|
|
)
|
|
|
|
func sender(context unsafe.Pointer) {
|
|
socket, _ := C.zmq_socket(context, C.ZMQ_PUSH)
|
|
defer C.zmq_close(socket)
|
|
|
|
C.zmq_connect(socket, C.CString("tcp://localhost:5555"))
|
|
|
|
// Sending a multi-part message
|
|
var message C.zmq_msg_t
|
|
|
|
// First part
|
|
C.zmq_msg_init_size(&message, C.size_t(5))
|
|
C.memcpy(C.zmq_msg_data(&message), unsafe.Pointer(C.CString("Hello")), C.size_t(5))
|
|
C.zmq_msg_send(&message, socket, C.ZMQ_SNDMORE)
|
|
C.zmq_msg_close(&message)
|
|
|
|
// Second part
|
|
C.zmq_msg_init_size(&message, C.size_t(6))
|
|
C.memcpy(C.zmq_msg_data(&message), unsafe.Pointer(C.CString("World!")), C.size_t(6))
|
|
C.zmq_msg_send(&message, socket, C.ZMQ_SNDMORE)
|
|
C.zmq_msg_close(&message)
|
|
|
|
// Last part
|
|
C.zmq_msg_init_size(&message, C.size_t(3))
|
|
C.memcpy(C.zmq_msg_data(&message), unsafe.Pointer(C.CString("End")), C.size_t(3))
|
|
C.zmq_msg_send(&message, socket, 0)
|
|
C.zmq_msg_close(&message)
|
|
}
|
|
|
|
func receiver(context unsafe.Pointer) {
|
|
socket, _ := C.zmq_socket(context, C.ZMQ_PULL)
|
|
defer C.zmq_close(socket)
|
|
|
|
C.zmq_bind(socket, C.CString("tcp://*:5555"))
|
|
|
|
for {
|
|
var message C.zmq_msg_t
|
|
C.zmq_msg_init(&message)
|
|
|
|
more := C.int(1)
|
|
moreSize := C.size_t(unsafe.Sizeof(more))
|
|
part := 0
|
|
|
|
for more != 0 {
|
|
C.zmq_msg_recv(&message, socket, 0)
|
|
|
|
size := C.zmq_msg_size(&message)
|
|
data := C.GoBytes(C.zmq_msg_data(&message), C.int(size))
|
|
|
|
part++
|
|
fmt.Printf("Received part %d: %s\n", part, string(data))
|
|
|
|
C.zmq_getsockopt(socket, C.ZMQ_RCVMORE, unsafe.Pointer(&more), &moreSize)
|
|
C.zmq_msg_close(&message)
|
|
|
|
if more != 0 {
|
|
C.zmq_msg_init(&message)
|
|
}
|
|
}
|
|
fmt.Println("End of multipart message\n")
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
context, _ := C.zmq_ctx_new()
|
|
defer C.zmq_ctx_destroy(context)
|
|
|
|
go sender(context)
|
|
time.Sleep(time.Second) // Give some time for the sender to connect
|
|
receiver(context)
|
|
}
|
|
``` |