Skip to main content
100%

Simplified zeromq PUSH/PULL example

✓ Published0🌍 Public
Aalper
Last edited Aug 10, 2012
Created on Aug 10, 2012

This example demonstrates a simple ZeroMQ PUSH/PULL message-passing pattern, where one process continuously generates random workloads and another receives and prints them. The pushventilator.py script uses `zmq.Context` and a PUSH socket to connect to a PULL socket bound on port 5558 by the pullsink.py process, sending random integers between 1 and 100 via `sink.send()`. The pullsink.py process uses `receiver.recv()` in a loop to display each received value, showing a real-time unidirectional data flow without any acknowledgment or synchronization beyond the initial connection.

AI-generated description

Similar vizzes

Loading thumbnail…

zmq ml template

A ZeroMQ REP socket on TCP port 5566 receives raw image frames as memory buffers, converts them to NumPy arrays, and feeds them through a preloaded Keras model for inference. The model processes each frame, clips the output to valid pixel ranges, concatenates an alpha channel, and sends the result back over the same socket. It logs inference and send times, calculates theoretical FPS, and handles errors by replying with an empty message.

Aaman-tiwari
53% match
Loading thumbnail…

Gist 919ad4cfb5475f2aa4b68109e6c02bc9

This example shows a Python script that configures and controls the LED Everloop on a MATRIX device. It first connects to the device’s data update port to count the available LEDs using `io_pb2.LedValue`, then sends a driver configuration with a fixed purple color to the base port via a ZeroMQ (ZMQ) PUSH socket. Using `zmq` and the `matrix_io` protocol buffers, it also pings a keep-alive port and registers an error callback. The script runs these tasks as separate processes with `multiprocessing`.

KKaitoKid
51% match
Loading thumbnail…

QueueWrite - asynchronous queue for stream output

The QueueWrite example demonstrates asynchronous stream throttling by piping the contents of `test.js` through a custom writable stream that queues chunks and limits concurrent write operations. A `delayPrint` function writes each chunk to stdout after a random delay of up to 200 milliseconds, while periodic console logs show the current open slot count and queue size. The code uses Node.js `stream.Writable`, `fs.createReadStream` with `lowWaterMark` and `highWaterMark` options, and `util.inherits` to implement the custom stream logic. Animation occurs through the timing of queued writes and the live stats output.

ZZJONSSON
48% match
Loading thumbnail…

multiprocessing

This example demonstrates a multiprocessing pipeline where eight producer processes concurrently process one hundred documents from a shared task queue, while the main process consumes and prints the results. The code uses Python's `multiprocessing` module, specifically the `Process`, `Queue`, and `join()` APIs to coordinate work and synchronization. Each producer pulls documents, simulates variable processing time with `time.sleep` and `random.uniform`, and pushes results to a separate result queue. The consumer function tracks completion until all documents are processed, illustrating a classic producer-consumer pattern with sentinel values to terminate workers.

JJastor11
48% match
Loading thumbnail…

MQTT Generator Script

This example demonstrates a script that generates simulated sensor data and publishes it to an MQTT broker. It functions as a data source for dashboards, creating random readings within configured ranges for multiple named sensors, each with geographic coordinates, units, and descriptions. The Python 3 script uses the `paho-mqtt` library to connect and publish JSON payloads to a specified topic at a configurable interval. It reads sensor definitions and broker settings from a `config.json` file, allowing users to add or modify sensors without changing the code. The script selects a sensor at random for each message, producing a continuous stream of test data for visualization or IoT development.

IIoTeacher
47% match
Loading thumbnail…

Gist 0df93cdbb2b3e218cfe40434c66d98e2

This example demonstrates a complete IoT telemetry pipeline where a micro:bit V2 sends temperature and light readings over USB serial to a Python gateway, which forwards them via MQTT to an AWS-hosted Mosquitto broker. The flow continues through Telegraf into InfluxDB, with Prometheus and Grafana for monitoring and visualization. The code uses MicroPython’s `temperature()` and `display.read_light_level()`, plus `pyserial` and `paho-mqtt` for serial communication and MQTT publishing. The architecture is illustrated with a Mermaid flowchart, and the gateway enriches JSON payloads with metadata before transmission.

IIoTeacher
47% match
Loading thumbnail…

Gist ef01d3ebfb3e6f5704bd

This example demonstrates a minimal WebSocket server implemented in Python, showing how to establish a handshake and exchange framed messages. It uses `SocketServer.StreamRequestHandler` for the network layer, manually performs the WebSocket handshake via `sha1` and `b64encode` against the defined magic string, and parses incoming frames by XOR-masking payload bytes. The code handles payload lengths up to 64-bit values and sends text frames with a 129 opcode. It prints received messages to the console, illustrating the core protocol mechanics without any visualization or data rendering.

Aahmohamed
46% match
Loading thumbnail…

zombie processes nodejs

This example demonstrates how to create a detached child process in Node.js that continues running independently of its parent. The code uses the `child_process.spawn` API to launch a new Node.js process executing `zombie.js`, with all standard streams (`stdin`, `stdout`, `stderr`) set to `'ignore'` and the `detached: true` option enabled. By calling `child.unref()`, the parent process removes the child from its event loop, allowing the parent to exit while the child persists as a zombie process. The example references Stack Overflow guidance and Node.js documentation on detached processes, illustrating a pattern for background tasks.

Aalessioalex
46% match