def test_server_resync(self):
from pizco import Server
app = QApplication([])
srv = RemotePizcoEmitterResync()
pizco_srv = Server(srv, rep_endpoint="tcp://127.0.0.1:1211")
from threading import Thread
import numpy as np
from guiqwt.plot import ImageWidget
from guiqwt.builder import make
import time
im = ImageWidget()
im.register_all_curve_tools()
ts = TestSync()
def test_thread():
ts.initialize_subobject(im)
srv.std_signal.connect(ts.receiver_int)
v_int = 0
while True:
v_int += 1
srv.emission()
time.sleep(0.5)
if v_int == 5:
break
im.close()
t = Thread(None, test_thread)
t.start()
im.show()
app.exec_()
pizco_srv.stop()
assert (ts._internal_value != 0)
def test_signal_two_proxies(self):
address = 'tcp://127.0.0.1:6009'
s = Server(Example(), rep_endpoint=address)
proxy1 = Proxy(address)
proxy2 = Proxy(address)
class MemMethod(object):
def __init__(self_):
self_.called = 0
def __call__(self_, value, old_value, others):
self_.called += 1
fun = MemMethod()
self.assertEqual(len(s.served_object.rw_prop_changed.slots), 0)
proxy2.rw_prop_changed.connect(fun)
time.sleep(SLEEP_SECS)
self.assertEqual(len(s.served_object.rw_prop_changed.slots), 1)
proxy1.p = 28
proxy1._proxy_stop_server()
proxy1._proxy_stop_me()
proxy2._proxy_stop_me()
def test_server(self):
s = Server(Example())
proxy = Proxy(s.rep_endpoint)
self.assertEqual(s.served_object.simple_attribute, 12)
self.assertEqual(proxy.simple_attribute, 12)
proxy.simple_attribute = 24
self.assertEqual(s.served_object.simple_attribute, 24)
self.assertEqual(proxy.simple_attribute, 24)
self.assertRaises(AttributeError, getattr, proxy, 'not_an_attribute')
self.assertEqual(s.served_object.dict_attribute[1], 2)
self.assertEqual(proxy.dict_attribute[1], 2)
self.assertRaises(KeyError, operator.getitem, proxy.dict_attribute, 2)
proxy.dict_attribute[2] = 4
self.assertEqual(s.served_object.dict_attribute[2], 4)
self.assertEqual(proxy.dict_attribute[2], 4)
self.assertEqual(s.served_object.rw_prop, 42)
self.assertEqual(proxy.rw_prop, 42)
proxy.rw_prop = 21
self.assertEqual(s.served_object.rw_prop, 21)
self.assertEqual(proxy.rw_prop, 21)
self.assertEqual(proxy.fun_simple(), 46)
self.assertEqual(proxy.fun_arg1(2), 4)
self.assertEqual(proxy.fun_arg2(2, 3), 8)
self.assertEqual(proxy.fun_arg2(y=2), 4)
self.assertRaises(ValueError, proxy.fun_raise)
proxy._proxy_stop_server()
proxy._proxy_stop_me()
def start(self, mode):
"""
In CLIENT_MODE:
Establish a connection with the server before sending a new message.
In SERVER_MODE:
Start listening to the incoming messages from the clients.
:param mode: (int) Either CLIENT_MODE or SERVER_MODE.
:return: None
"""
address = 'tcp://{}:{}'.format(self.ip, self.port)
if mode == CLIENT_MODE:
self.mode = mode
self.logger.info(
"Starting Scoreboard Client listening on {}:{} ...".format(
self.ip, self.port))
self.instance = Proxy(address)
elif mode == SERVER_MODE:
self.mode = mode
self.scoreboard = Scoreboard()
server = Server(self, address)
self.logger.info(
"Starting Scoreboard Server listening on {}:{} ...".format(
self.ip, self.port))
server.serve_forever()
def test_signal(self):
address = 'tcp://127.0.0.1:6008'
s = Server(Example(), rep_endpoint=address)
proxy = Proxy(address)
class MemMethod(object):
def __init__(self_):
self_.called = 0
def __call__(self_, value, old_value, others):
self_.called += 1
fun1 = MemMethod()
self.assertEqual(fun1.called, 0)
self.assertEqual(len(s.served_object.rw_prop_changed.slots), 0)
proxy.rw_prop_changed.connect(fun1)
time.sleep(SLEEP_SECS)
self.assertEqual(len(s.served_object.rw_prop_changed.slots), 1)
proxy.rw_prop = 28
time.sleep(SLEEP_SECS)
self.assertEqual(proxy.rw_prop, 28)
self.assertEqual(fun1.called, 1)
fun2 = MemMethod()
self.assertEqual(fun2.called, 0)
proxy.rw_prop_changed.connect(fun2)
time.sleep(SLEEP_SECS)
self.assertEqual(len(s.served_object.rw_prop_changed.slots), 1)
proxy.rw_prop = 29
time.sleep(SLEEP_SECS)
self.assertEqual(proxy.rw_prop, 29)
self.assertEqual(fun1.called, 2)
self.assertEqual(fun2.called, 1)
proxy.rw_prop_changed.disconnect(fun1)
time.sleep(SLEEP_SECS)
self.assertEqual(len(s.served_object.rw_prop_changed.slots), 1)
proxy.rw_prop = 30
self.assertEqual(fun1.called, 2)
proxy.rw_prop_changed.disconnect(fun2)
time.sleep(SLEEP_SECS)
self.assertEqual(len(s.served_object.rw_prop_changed.slots), 0)
proxy.rw_prop_changed.connect(fun1)
proxy.rw_prop_changed.connect(fun2)
time.sleep(SLEEP_SECS)
self.assertEqual(len(s.served_object.rw_prop_changed.slots), 1)
proxy.rw_prop_changed.disconnect(None)
time.sleep(SLEEP_SECS)
self.assertEqual(len(s.served_object.rw_prop_changed.slots), 0)
proxy._proxy_stop_server()
proxy._proxy_stop_me()
def main(args=None):
import argparse
parser = argparse.ArgumentParser('Starts an server')
parser.add_argument(
'-g',
'--gui',
action='store_true',
help='Open a small window to display the server status.')
parser.add_argument('-v',
'--verbose',
action='store_true',
help='Print debug information to the console.')
parser.add_argument('-p',
'--path',
type=str,
help='Append this path to sys.path')
parser.add_argument('rep_endpoint', help='REP endpoint of the Server')
parser.add_argument('pub_endpoint', help='PUB endpoint of the Server')
args = parser.parse_args(args)
if args.path:
sys.path.append(args.path)
if args.verbose:
LOGGER.addHandler(logging.StreamHandler())
LOGGER.setLevel(logging.DEBUG)
from pizco import Server
s = Server(None, args.rep_endpoint, args.pub_endpoint)
print('Server started at {}'.format(s.rep_endpoint))
if args.gui:
if sys.version_info < (3, 0):
from Tkinter import Tk, Label
else:
from tkinter import Tk, Label
import time
while s.served_object is None:
time.sleep(.1)
name = s.served_object.__class__.__name__
root = Tk()
root.title('Pizco Server: {}'.format(name))
Label(root, text='{}'.format(name)).pack(padx=5)
Label(root, text='REP: {}'.format(s.rep_endpoint)).pack(padx=5)
Label(root, text='PUB: {}'.format(s.pub_endpoint)).pack(padx=5)
root.resizable(width=False, height=False)
root.mainloop()
else:
print('Press CTRL+c to stop ...')
s.serve_forever()
print('Server stopped')
def test_future(self):
s = Server(Example())
proxy = Proxy(s.rep_endpoint)
fut = proxy.fut()
self.assertEqual(fut.result(), 10)
fut = proxy.fut_raise()
self.assertIsInstance(fut.exception(), ValueError)
fut = proxy.fut_raise()
self.assertRaises(ValueError, fut.result)
proxy._proxy_stop_me()
s.stop()
# -*- coding: utf-8 -*- from pizco import Server from common import House s = Server(House(), 'tcp://127.0.0.1:8000') s.serve_forever()
