Zmq - Revision history

Admin: /* Pair Model */

2018-02-16T12:00:32Z

Pair Model

@@ Line 135: / Line 135: @@
      print(d)
      time.sleep(1)
 </pre>

Admin at 11:42, 16 February 2018

2018-02-16T11:42:09Z

← Older revision		Revision as of 11:42, 16 February 2018
Line 7:		Line 7:
	Documentation: https://pyzmq.readthedocs.io/		Documentation: https://pyzmq.readthedocs.io/

	==Pair Model: Simple Client and Server==		==Pair Model==

			The pair model for ZMQ consists of a pair of instances: one client and one server.

			===Pair Model: Simple Client and Server===

	The following two files, pairclient.py and pairserver.py, illustrate the simplest possile pair model for zmq.		The following two files, pairclient.py and pairserver.py, illustrate the simplest possile pair model for zmq.
Line 73:		Line 77:
	</pre>		</pre>

	==Pair Model: Json Client and Server==		===Pair Model: Json Client and Server===

	The following example expands on the prior example, and shows how to build a ZMQ client/server pair that send and receive JSON data:		The following example expands on the prior example, and shows how to build a ZMQ client/server pair that send and receive JSON data:

Admin: /* Pair Model: Simple Client and Server */

2018-02-16T11:41:01Z

Pair Model: Simple Client and Server

← Older revision		Revision as of 11:41, 16 February 2018
Line 71:		Line 71:

	time.sleep(5)		time.sleep(5)
			</pre>

			==Pair Model: Json Client and Server==

			The following example expands on the prior example, and shows how to build a ZMQ client/server pair that send and receive JSON data:

			'''jsonclient.py:'''

			<pre>
			import json
			import zmq
			import random
			import sys
			import time

			port = "5556"
			context = zmq.Context()
			socket = context.socket(zmq.PAIR)
			socket.connect("tcp://localhost:%s" % port)

			for i in range(50):
			## Send as string
			#d = dict(apples=random.randint(1,1000), oranges=random.randint(1,1000), bananas=random.randint(1,1000))
			#print("sending data %s"%(json.dumps(d)))
			#socket.send_string("%s"%json.dumps(d))
			#time.sleep(0.1)

			# Send as dict
			d = dict(apples=random.randint(1,1000), oranges=random.randint(1,1000), bananas=random.randint(1,1000))
			print("sending data %s"%(d))
			socket.send_json(d)
			time.sleep(0.1)
			</pre>

			'''jsonserver.py:'''

			<pre>
			import json
			import zmq
			import random
			import sys
			import time

			port = "5556"
			context = zmq.Context()
			socket = context.socket(zmq.PAIR)
			socket.bind("tcp://*:%s" % port)

			while True:
			## Receive as string
			#msg = socket.recv()
			#d = json.loads(msg)
			#print(d)
			#time.sleep(1)

			# Receive as json
			d = socket.recv_json()
			print(type(d))
			print(d)
			time.sleep(1)
	</pre>		</pre>

Admin at 11:39, 16 February 2018

2018-02-16T11:39:19Z

← Older revision		Revision as of 11:39, 16 February 2018
Line 1:		Line 1:
			=Notes=

	Zmq (abbreviation for Zero MQ) is messaging queue software.		Zmq (abbreviation for Zero MQ) is messaging queue software.

Line 69:		Line 71:

	time.sleep(5)		time.sleep(5)
			</pre>

			=Flags=

			[[Category:Zmq]]
			[[Category:Python]]

			[[Category:2018]]
			[[Category:February 2018]]

Admin at 11:38, 16 February 2018

2018-02-16T11:38:26Z

← Older revision		Revision as of 11:38, 16 February 2018
Line 4:		Line 4:

	Documentation: https://pyzmq.readthedocs.io/		Documentation: https://pyzmq.readthedocs.io/

			==Pair Model: Simple Client and Server==

			The following two files, pairclient.py and pairserver.py, illustrate the simplest possile pair model for zmq.

			'''pairclient.py:'''

			<pre>
			import zmq
			import random
			import sys
			import time

			"""
			ZMQ Pair Client

			This generates test messages every half second,
			faster than the server will print/process the
			messages. This just illustrates that ZMQ will
			store messages in a queue as they come in, and
			will not throw messages away.
			"""

			port = "5556"
			context = zmq.Context()
			socket = context.socket(zmq.PAIR)
			socket.connect("tcp://localhost:%s" % port)

			i = 0
			while True:
			i += 1
			socket.send_string("ping %d"%(i))
			time.sleep(0.5)
			</pre>

			'''pairserver.py:'''

			<pre>
			import zmq
			import random
			import sys
			import time

			"""
			ZMQ Pair Server

			This accepts messages from a ZMQ message queue
			and prints them at a rate of two per five seconds.
			This is slower than the client generates messages.
			Thils illustrates the queue behavior of ZMQ.
			"""

			port = "5556"
			context = zmq.Context()
			socket = context.socket(zmq.PAIR)
			socket.bind("tcp://*:%s" % port)

			while True:
			msg = socket.recv()
			print(msg)

			msg = socket.recv()
			print(msg)

			time.sleep(5)

Admin at 11:31, 16 February 2018

2018-02-16T11:31:13Z

← Older revision		Revision as of 11:31, 16 February 2018
Line 2:		Line 2:

	Messaging queue software follows the pub/sub (publisher/subscriber) architecture. This involves creating asychronous messaging pipelines. Agents that are creating events can publish to a pipeline, while agents that are processing events can subscribe to a pipeline.		Messaging queue software follows the pub/sub (publisher/subscriber) architecture. This involves creating asychronous messaging pipelines. Agents that are creating events can publish to a pipeline, while agents that are processing events can subscribe to a pipeline.

			Documentation: https://pyzmq.readthedocs.io/

Admin: Created page with "Zmq (abbreviation for Zero MQ) is messaging queue software. Messaging queue software follows the pub/sub (publisher/subscriber) architecture. This involves creating asychrono..."

2018-02-16T11:30:18Z

Created page with "Zmq (abbreviation for Zero MQ) is messaging queue software. Messaging queue software follows the pub/sub (publisher/subscriber) architecture. This involves creating asychrono..."

New page

Zmq (abbreviation for Zero MQ) is messaging queue software.

Messaging queue software follows the pub/sub (publisher/subscriber) architecture. This involves creating asychronous messaging pipelines. Agents that are creating events can publish to a pipeline, while agents that are processing events can subscribe to a pipeline.