def test_pub_sub_select_channel(self): # Connect self._context1.bind("localhost:test1") self._context2.connect("localhost:test1") # Create channels pub1 = yoton.PubChannel(self._context1, "foo1") pub2 = yoton.PubChannel(self._context1, "foo2") # sub1 = yoton.SubChannel(self._context2, "foo1") sub2 = yoton.SubChannel(self._context2, "foo2") # Send a bunch of messages ii = [0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1] for i in range(len(ii)): pub = [pub1, pub2][ii[i]] pub.send(str(i)) time.sleep(0.1) # Receive in right order count = 0 while True: sub = yoton.select_sub_channel(sub1, sub2) if sub: i = int(sub.recv()) self.assertEqual(i, count) count += 1 else: break # Test count self.assertEqual(count, len(ii))
def setUp(self): # Create contexts self._context1 = c1 = yoton.Context() self._context2 = c2 = yoton.Context() self._context3 = c3 = yoton.Context() # Create pub sub channels self._channel_pub1 = yoton.PubChannel(c1, "foo") self._channel_pub2 = yoton.PubChannel(c2, "foo") self._channel_pub3 = yoton.PubChannel(c3, "foo") # self._channel_sub1 = yoton.SubChannel(c1, "foo") self._channel_sub2 = yoton.SubChannel(c2, "foo") self._channel_sub3 = yoton.SubChannel(c3, "foo") # Create req rep channels self._channel_req1 = yoton.ReqChannel(c1, "bar") self._channel_req2 = yoton.ReqChannel(c2, "bar") self._channel_req3 = yoton.ReqChannel(c3, "bar") # self._channel_rep1 = yoton.RepChannel(c1, "bar") self._channel_rep2 = yoton.RepChannel(c2, "bar") self._channel_rep3 = yoton.RepChannel(c3, "bar") # Create state channels self._channel_state1 = yoton.StateChannel(c1, "spam") self._channel_state2 = yoton.StateChannel(c2, "spam") self._channel_state3 = yoton.StateChannel(c3, "spam")
def connectToKernel(self, info): """ connectToKernel() Create kernel and connect to it. """ # Create yoton context self._context = ct = yoton.Context() # Create stream channels self._strm_out = yoton.SubChannel(ct, 'strm-out') self._strm_err = yoton.SubChannel(ct, 'strm-err') self._strm_raw = yoton.SubChannel(ct, 'strm-raw') self._strm_echo = yoton.SubChannel(ct, 'strm-echo') self._strm_prompt = yoton.SubChannel(ct, 'strm-prompt') self._strm_broker = yoton.SubChannel(ct, 'strm-broker') self._strm_action = yoton.SubChannel(ct, 'strm-action', yoton.OBJECT) # Set channels to sync mode. This means that if the IEP cannot process # the messages fast enough, the sending side is blocked for a short # while. We don't want our users to miss any messages. for c in [self._strm_out, self._strm_err]: c.set_sync_mode(True) # Create control channels self._ctrl_command = yoton.PubChannel(ct, 'ctrl-command') self._ctrl_code = yoton.PubChannel(ct, 'ctrl-code', yoton.OBJECT) self._ctrl_broker = yoton.PubChannel(ct, 'ctrl-broker') # Create status channels self._stat_interpreter = yoton.StateChannel(ct, 'stat-interpreter') self._stat_debug = yoton.StateChannel(ct, 'stat-debug', yoton.OBJECT) self._stat_startup = yoton.StateChannel(ct, 'stat-startup', yoton.OBJECT) self._stat_startup.received.bind(self._onReceivedStartupInfo) # Create introspection request channel self._request = yoton.ReqChannel(ct, 'reqp-introspect') # Connect! The broker will only start the kernel AFTER # we connect, so we do not miss out on anything. slot = iep.localKernelManager.createKernel(finishKernelInfo(info)) self._brokerConnection = ct.connect('localhost:%i' % slot) self._brokerConnection.closed.bind(self._onConnectionClose)
def _create_channels(self): ct = self._context # Close any existing channels first self._context.close_channels() # Create stream channels. # Stdout is for the C-level stdout/stderr streams. self._strm_broker = yoton.PubChannel(ct, 'strm-broker') self._strm_raw = yoton.PubChannel(ct, 'strm-raw') self._strm_prompt = yoton.PubChannel(ct, 'strm-prompt') # Create control channel so that the IDE can control restarting etc. self._ctrl_broker = yoton.SubChannel(ct, 'ctrl-broker') # Status channel to pass startup parameters to the kernel self._stat_startup = yoton.StateChannel(ct, 'stat-startup', yoton.OBJECT) # We use the stat-interpreter to set the status to dead when kernel dies self._stat_interpreter = yoton.StateChannel(ct, 'stat-interpreter') # Create introspect channel so we can interrupt and terminate self._reqp_introspect = yoton.ReqChannel(ct, 'reqp-introspect')
import time import yoton import __main__ # we will run code in the __main__.__dict__ namespace ## Make connection object and get channels # Create a yoton context. All channels are stored at the context. ct = yoton.Context() # Create control channels ct._ctrl_command = yoton.SubChannel(ct, 'ctrl-command') ct._ctrl_code = yoton.SubChannel(ct, 'ctrl-code', yoton.OBJECT) # Create stream channels ct._strm_out = yoton.PubChannel(ct, 'strm-out') ct._strm_err = yoton.PubChannel(ct, 'strm-err') ct._strm_echo = yoton.PubChannel(ct, 'strm-echo') ct._strm_prompt = yoton.PubChannel(ct, 'strm-prompt') ct._strm_action = yoton.PubChannel(ct, 'strm-action', yoton.OBJECT) # Create status channels ct._stat_interpreter = yoton.StateChannel(ct, 'stat-interpreter') ct._stat_debug = yoton.StateChannel(ct, 'stat-debug', yoton.OBJECT) ct._stat_startup = yoton.StateChannel(ct, 'stat-startup', yoton.OBJECT) ct._stat_breakpoints = yoton.StateChannel(ct, 'stat-breakpoints', yoton.OBJECT) # Connect (port number given as command line argument) # Important to do this *before* replacing the stdout etc, because if an # error occurs here, it will be printed in the shell. port = int(sys.argv[1])
# / ct3 # ct1 - ct2 # \ ct4 - ct5 ct1.bind('localhost:split1') ct2.connect('localhost:split1') # ct2.bind('localhost:split2') ct3.connect('localhost:split2') # ct2.bind('localhost:split3') ct4.connect('localhost:split3') # ct4.bind('localhost:split4') ct5.connect('localhost:split4') # Create channels if True: pub1 = yoton.PubChannel(ct1, 'splittest') sub1 = yoton.SubChannel(ct3, 'splittest') sub2 = yoton.SubChannel(ct5, 'splittest') else: pub1 = yoton.StateChannel(ct1, 'splittest') sub1 = yoton.StateChannel(ct3, 'splittest') sub2 = yoton.StateChannel(ct5, 'splittest') # Go! pub1.send('Hello you two!') time.sleep(0.5) print(sub1.recv()) print(sub2.recv())
# Create custom message type. (should be defined at both ends) class NumberMessageType(yoton.MessageType): def message_from_bytes(self, bb): return float(bb.decode("utf-8")) def message_to_bytes(self, number): return str(number).encode("utf-8") def message_type_name(self): return "num" # Create context, a channel, and connect ct1 = yoton.Context(verbose=verbosity) pub = yoton.PubChannel(ct1, "numbers", NumberMessageType) ct1.bind("publichost:test") # Send a message pub.send(42.9) ## ========== Other end import yoton verbosity = 0 # Create custom message type. (should be defined at both ends) class NumberMessageType(yoton.MessageType): def message_from_bytes(self, bb):
# -*- coding: utf-8 -*- # This example illustrates a simple pub/sub pattern. # This example can be run in one go or in two parts running in # different processes. ## ========== One end import yoton verbosity = 0 # Python 2.4 can crash with verbosity on # Create one context and a pub channel ct1 = yoton.Context(verbose=verbosity) pub = yoton.PubChannel(ct1, 'chat') # Connect ct1.bind('publichost:test') # Send pub.send('hello world') ## ========== Other end import yoton verbosity = 0 # Create another context and a sub channel ct2 = yoton.Context(verbose=verbosity) sub = yoton.SubChannel(ct2, 'chat') # Connect ct2.connect('publichost:test')
# -*- coding: utf-8 -*- # This example creates three contexts that are connected in a row. # A message is send at the first and received at the last. import yoton # Three contexts verbosity = 2 c1 = yoton.Context(verbosity) c2 = yoton.Context(verbosity) c3 = yoton.Context(verbosity) c4 = yoton.Context(verbosity) # Connect in a row addr = "localhost:whop" c1.bind(addr + "+1") c2.connect(addr + "+1") c2.bind(addr + "+2") c3.connect(addr + "+2") c3.bind(addr + "+3") c4.connect(addr + "+3") # Create pub at first and sub at last p = yoton.PubChannel(c1, "hop") s = yoton.SubChannel(c4, "hop") # Send a message. p.send("hophophop") print(s.recv())
# -*- coding: utf-8 -*- # This example demponstrates simple pub sub. # # This time in event driven mode. This example only works locally, as # we cannot start two event loops :) ## ========== One end import yoton verbosity = 0 # Create a context and a pub channel ct1 = yoton.Context(verbose=verbosity) pub = yoton.PubChannel(ct1, "foo") # Connect and turn duplicator on ct1.bind("publichost:test") ## ========== Other end import yoton verbosity = 0 # Create a context and a sub channel ct2 = yoton.Context(verbose=verbosity) sub = yoton.SubChannel(ct2, "foo") # Connect, set channel to event driven mode
# -*- coding: utf-8 -*- # This example illustrates a simple pub/sub pattern. # This example can be run in one go or in two parts running in # different processes. ## ========== One end import yoton verbosity = 0 # Python 2.4 can crash with verbosity on # Create one context and a pub channel ct1 = yoton.Context(verbose=verbosity) pub = yoton.PubChannel(ct1, "chat") # Connect ct1.bind("publichost:test") # Send pub.send("hello world") ## ========== Other end import yoton verbosity = 0 # Create another context and a sub channel ct2 = yoton.Context(verbose=verbosity) sub = yoton.SubChannel(ct2, "chat")
import yoton verbosity = 0 # Create custom message type. (should be defined at both ends) class NumberMessageType(yoton.MessageType): def message_from_bytes(self, bb): return float(bb.decode('utf-8')) def message_to_bytes(self, number): return str(number).encode('utf-8') def message_type_name(self): return 'num' # Create context, a channel, and connect ct1 = yoton.Context(verbose=verbosity) pub = yoton.PubChannel(ct1, 'numbers', NumberMessageType) ct1.bind('publichost:test') # Send a message pub.send(42.9) ## ========== Other end import yoton verbosity = 0 # Create custom message type. (should be defined at both ends) class NumberMessageType(yoton.MessageType): def message_from_bytes(self, bb): return float(bb)
sys.path.insert(0, ".") # Import yoton from there import yoton # Normal imports import math import time import visvis as vv ## Run experiment with different message sizes # Setup host ct1 = yoton.Context() ct1.bind("localhost:test") c1 = yoton.PubChannel(ct1, "speedTest") # Setup client ct2 = yoton.SimpleSocket() ct2.connect("localhost:test") c2 = yoton.SubChannel(ct2, "speedTest") # Init minSize, maxSize = 2, 100 * 2**20 BPS = [] TPM = [] N = [] SIZE = [] # Loop size = minSize
# -*- coding: utf-8 -*- # This example creates three contexts that are connected in a row. # A message is send at the first and received at the last. import yoton # Three contexts verbosity = 2 c1 = yoton.Context(verbosity) c2 = yoton.Context(verbosity) c3 = yoton.Context(verbosity) c4 = yoton.Context(verbosity) # Connect in a row addr = 'localhost:whop' c1.bind(addr + '+1') c2.connect(addr + '+1') c2.bind(addr + '+2') c3.connect(addr + '+2') c3.bind(addr + '+3') c4.connect(addr + '+3') # Create pub at first and sub at last p = yoton.PubChannel(c1, 'hop') s = yoton.SubChannel(c4, 'hop') # Send a message. p.send('hophophop') print(s.recv())
# / ct3 # ct1 - ct2 # \ ct4 - ct5 ct1.bind("localhost:split1") ct2.connect("localhost:split1") # ct2.bind("localhost:split2") ct3.connect("localhost:split2") # ct2.bind("localhost:split3") ct4.connect("localhost:split3") # ct4.bind("localhost:split4") ct5.connect("localhost:split4") # Create channels if True: pub1 = yoton.PubChannel(ct1, "splittest") sub1 = yoton.SubChannel(ct3, "splittest") sub2 = yoton.SubChannel(ct5, "splittest") else: pub1 = yoton.StateChannel(ct1, "splittest") sub1 = yoton.StateChannel(ct3, "splittest") sub2 = yoton.StateChannel(ct5, "splittest") # Go! pub1.send("Hello you two!") time.sleep(0.5) print(sub1.recv()) print(sub2.recv())
import sys import time import yoton import __main__ # we will run code in the __main__.__dict__ namespace ## Make connection object and get channels # Create a yoton context. All channels are stored at the context. ct = yoton.Context() # Create control channels ct._ctrl_command = yoton.SubChannel(ct, "ctrl-command") ct._ctrl_code = yoton.SubChannel(ct, "ctrl-code", yoton.OBJECT) # Create stream channels ct._strm_out = yoton.PubChannel(ct, "strm-out") ct._strm_err = yoton.PubChannel(ct, "strm-err") ct._strm_echo = yoton.PubChannel(ct, "strm-echo") ct._strm_prompt = yoton.PubChannel(ct, "strm-prompt") ct._strm_action = yoton.PubChannel(ct, "strm-action", yoton.OBJECT) # Create status channels ct._stat_interpreter = yoton.StateChannel(ct, "stat-interpreter") ct._stat_cd = yoton.StateChannel(ct, "stat-cd") ct._stat_debug = yoton.StateChannel(ct, "stat-debug", yoton.OBJECT) ct._stat_startup = yoton.StateChannel(ct, "stat-startup", yoton.OBJECT) ct._stat_breakpoints = yoton.StateChannel(ct, "stat-breakpoints", yoton.OBJECT) # Connect (port number given as command line argument) # Important to do this *before* replacing the stdout etc, because if an # error occurs here, it will be printed in the shell.
# -*- coding: utf-8 -*- # This example demponstrates simple pub sub. # # This time in event driven mode. This example only works locally, as # we cannot start two event loops :) ## ========== One end import yoton verbosity = 0 # Create a context and a pub channel ct1 = yoton.Context(verbose=verbosity) pub = yoton.PubChannel(ct1, 'foo') # Connect and turn duplicator on ct1.bind('publichost:test') ## ========== Other end import yoton verbosity = 0 # Create a context and a sub channel ct2 = yoton.Context(verbose=verbosity) sub = yoton.SubChannel(ct2, 'foo') # Connect, set channel to event driven mode ct2.connect('publichost:test')
sys.path.insert(0,'.') # Import yoton from there import yoton # Normal imports import math import time import visvis as vv ## Run experiment with different message sizes # Setup host ct1 = yoton.Context() ct1.bind('localhost:test') c1 = yoton.PubChannel(ct1, 'speedTest') # Setup client ct2 = yoton.SimpleSocket() ct2.connect('localhost:test') c2 = yoton.SubChannel(ct2, 'speedTest') # Init minSize, maxSize = 2, 100*2**20 BPS = [] TPM = [] N = [] SIZE = [] # Loop