def test_default_handler():
results = []
def test(address, *values):
results.append((address, values))
osc = OSCThreadServer(default_handler=test)
osc.listen(default=True)
@osc.address(b'/passthrough')
def passthrough(*values):
pass
osc.send_bundle((
(b'/test', []),
(b'/passthrough', []),
(b'/test/2', [1, 2, 3]),
), *osc.getaddress())
timeout = time() + 2
while len(results) < 2:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
sleep(10e-9)
expected = (
(b'/test', tuple()),
(b'/test/2', (1, 2, 3)),
)
for e, r in zip(expected, results):
assert e == r
def test_bind_multi():
osc = OSCThreadServer()
sock1 = osc.listen()
port1 = sock1.getsockname()[1]
sock2 = osc.listen()
port2 = sock2.getsockname()[1]
cont = []
def success1(*values):
cont.append(True)
def success2(*values):
cont.append(False)
osc.bind(b'/success', success1, sock1)
osc.bind(b'/success', success2, sock2)
send_message(b'/success', [b'test', 1, 1.12345], 'localhost', port1)
send_message(b'/success', [b'test', 1, 1.12345], 'localhost', port2)
timeout = time() + 5
while len(cont) < 2:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
assert True in cont and False in cont
def test_get_routes():
osc = OSCThreadServer(encoding='utf8')
osc.listen(default=True)
values = []
@osc.address(u'/test_route')
def dummy(*val):
pass
@osc.address(u'/_oscpy/routes/answer')
def cb(*routes):
values.extend(routes)
send_message(b'/_oscpy/routes', [osc.getaddress()[1]],
*osc.getaddress(),
encoding='utf8',
encoding_errors='strict')
timeout = time() + 2
while not values:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
sleep(10e-9)
assert u'/test_route' in values
def test_send_bundle_without_socket():
osc = OSCThreadServer()
with pytest.raises(RuntimeError):
osc.send_bundle([], 'localhost', 0)
osc.listen(default=True)
osc.send_bundle(((b'/test', []), ), 'localhost', 1)
def setup_service():
Logger.info('service: setup_service')
setup_logger('mi')
# add this dir to module search path
app_dir = os.path.join(mi2app_utils.get_files_dir(), "app")
sys.path.append(os.path.join(app_dir, 'service'))
Logger.info('service: sys path added: ' + str(sys.path))
# setup control and listen to osc signal
control = Control()
Logger.info('service: control created' + repr(control))
osc = OSCThreadServer()
osc.listen(port=OSCConfig.service_port, default=True)
# def dummy_callback(msg, *args):
# Logger.info('service: dummy callback: ' + str(msg))
# osc.bind(OSCID, dummy_callback, OSCConfig.control_addr)
osc.bind(bytes(OSCConfig.control_addr, "ascii"), control.osc_callback)
# Logger.info('service: osc setup, id: ' + OSCID)
Logger.info('service: osc setup')
gps_provider = GpsListener(on_gps)
gps_provider.start()
osc_client = OSCClient("127.0.0.1", OSCConfig.service_port)
osc_client.send_message(bytes(OSCConfig.control_addr, "ascii"), ['service ready',])
Logger.info('service SEND>: service ready msg sent')
while True:
# osc.readQueue(thread_id=OSCID)
time.sleep(.5)
def __dump(options):
def dump(address, *values):
print(u'{}: {}'.format(
address.decode('utf8'),
', '.join(
'{}'.format(
v.decode(options.encoding or 'utf8')
if isinstance(v, bytes)
else v
)
for v in values if values
)
))
osc = OSCThreadServer(
encoding=options.encoding,
encoding_errors=options.encoding_errors,
default_handler=dump
)
osc.listen(
address=options.host,
port=options.port,
default=True
)
return osc
def test_listen_default():
osc = OSCThreadServer()
sock = osc.listen(default=True)
with pytest.raises(RuntimeError) as e_info: # noqa
osc.listen(default=True)
osc.close(sock)
osc.listen(default=True)
def test_getaddress():
osc = OSCThreadServer()
sock = osc.listen()
assert osc.getaddress(sock)[0] == '127.0.0.1'
with pytest.raises(RuntimeError):
osc.getaddress()
sock2 = osc.listen(default=True)
assert osc.getaddress(sock2)[0] == '127.0.0.1'
osc.stop(sock)
def test_stop_all():
osc = OSCThreadServer()
sock = osc.listen(default=True)
host, port = sock.getsockname()
osc.listen()
assert len(osc.sockets) == 2
osc.stop_all()
assert len(osc.sockets) == 0
osc.listen(address=host, port=port)
assert len(osc.sockets) == 1
osc.stop_all()
def test_close():
osc = OSCThreadServer()
osc.listen(default=True)
osc.close()
with pytest.raises(RuntimeError) as e_info: # noqa
osc.close()
if platform != 'win32':
filename = mktemp()
unix = osc.listen(address=filename, family='unix')
assert exists(filename)
osc.close(unix)
assert not exists(filename)
def follow_logs(self):
try:
server = OSCThreadServer(encoding='utf8')
server.listen(address='127.0.0.1', port=4558, default=True)
server.bind('/log/multi_message', self.handle_multi_message)
server.bind('/multi_message', self.handle_multi_message)
server.bind('/log/info', self.handle_log_info)
server.bind('/info', self.handle_log_info)
server.bind('/error', self.handle_runtime_error)
server.bind('/syntax_error', self.handle_syntax_error)
while True:
time.sleep(1)
except Exception as e:
return e
class OSC:
"""Ne fait que envoyer avec self.client
et recevoir avec self.server, en com avec service.py
"""
def __init__(self):
self.sensor = "\nRecherche d'un capteur ..."
# a, b, c, activity, num, tempo
self.display_list = [0, 0, 0, 0, 0, 1, 0]
# Conservation de tout l'historique
self.histo_xyz = []
self.server = OSCThreadServer()
self.server.listen(address=b'localhost', port=3003, default=True)
self.server.bind(b'/acc', self.on_acc)
self.server.bind(b'/sensor', self.on_sensor)
self.server.bind(b'/offset', self.on_offset)
self.client = OSCClient(b'localhost', 3001)
self.t_init = None
def on_offset(self, offset):
"""Valeur possible: Android Virtual No sensor"""
self.offset = offset * 1000000
print("self.offset =", self.offset)
def on_sensor(self, sens):
"""Valeur possible: Android Virtual No sensor"""
self.sensor = sens.decode('utf-8')
def on_acc(self, *args):
# Nessressaire pour maj affichage si acc ne tourne pas
self.display_list = [
args[0], args[1], args[2], args[3], args[4], args[5], args[6]
]
a, b, c, t = (args[0], args[1], args[2], args[6])
# dans service: t=int(time()*1000)-1604000000000 avec get_datetime()
t_absolute = get_datetime(t, self.offset)
# Datetime du début
if not self.t_init:
self.t_init = t_absolute
t_relativ = t_absolute - self.t_init
# En secondes
tx = t_relativ.total_seconds()
norme = int((a**2 + b**2 + c**2)**0.5)
# Par axe
if norme > 1: # Bug au début
self.histo_xyz.append((tx, (a, b, c)))
def test_server_different_port():
# server, will be tested:
server_3000 = OSCThreadServer(encoding='utf8')
sock_3000 = server_3000.listen(address='0.0.0.0', port=3000, default=True)
server_3000.bind(b'/callback_3000', callback_3000)
# clients sending to different ports, used to test the server:
client_3000 = OSCClient(address='localhost', port=3000, encoding='utf8')
# server sends message to himself, should work:
server_3000.send_message(b'/callback_3000', ["a"],
ip_address='localhost',
port=3000)
sleep(0.05)
# client sends message to server, will be received properly:
client_3000.send_message(b'/callback_3000', ["b"])
sleep(0.05)
# sever sends message on different port, might crash the server on windows:
server_3000.send_message(b'/callback_3000',
["nobody is going to receive this"],
ip_address='localhost',
port=3001)
sleep(0.05)
# client sends message to server again. if server is dead, message will not be received:
client_3000.send_message(b'/callback_3000', ["c"])
sleep(0.1) # give time to finish transmissions
# if 'c' is missing in the received checklist, the server thread crashed and could not recieve the last message from the client:
assert checklist == ['a', 'b', 'c']
server_3000.stop() # clean up
def create_osc_listener(port=8000, callback=None):
'''
Create a threaded OSC server that listens for incoming UDP messages
'''
from oscpy.server import OSCThreadServer
logger.debug('[create_osc_listener port={}]'.format(port))
def converter(addr, *args):
logger.debug("[create_osc_listener.converter] addr={} args={}".format(addr, args))
if callback:
callback(addr.decode('utf-8'), args)
osc = OSCThreadServer(advanced_matching=True, encoding='utf8', default_handler=converter) # See sources for all the arguments
sock = osc.listen(address='0.0.0.0', port=port, default=True)
# osc.bind_all(converter, get_address=True)
def disconnect():
osc.stop() # Stop the default socket
osc.stop_all() # Stop all sockets
# Here the server is still alive, one might call osc.listen() again
osc.terminate_server() # Request the handler thread to stop looping
osc.join_server()
return osc, disconnect
def test_oscclient():
osc = OSCThreadServer()
sock = osc.listen()
port = sock.getsockname()[1]
acc = []
def success(*values):
acc.append(values[0])
osc.bind(b'/success', success, sock)
client = OSCClient('localhost', port)
timeout = time() + 5
while len(acc) < 50:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
client.send_message(b'/success', [1])
while len(acc) < 100:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
client.send_bundle([(b'/success', [i]) for i in range(10)])
def test_validate_message_address_disabled():
osc = OSCThreadServer(validate_message_address=False)
osc.listen(default=True)
received = []
@osc.address(b'malformed')
def malformed(*val):
received.append(val[0])
send_message(b'malformed', [b'message'], *osc.getaddress())
timeout = time() + 2
while not received:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
sleep(10e-9)
def test_bind_default():
osc = OSCThreadServer()
osc.listen(default=True)
port = osc.getaddress()[1]
cont = []
def success(*values):
cont.append(True)
osc.bind(b'/success', success)
send_message(b'/success', [b'test', 1, 1.12345], 'localhost', port)
timeout = time() + 5
while not cont:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
def receive_values_from_max(ip, port):
while (1):
osc = OSCThreadServer()
sock = osc.listen(address=ip, port=port, default=True)
#osc.bind(b'/crowd-accel',acceleration_data)
osc.bind(b'/crowd-pos', positional_data)
sleep(1)
osc.stop()
return True
def receive_values_from_max(ip, port):
while (1):
osc = OSCThreadServer()
sock = osc.listen(address=ip, port=port, default=True)
osc.bind(b'/density', printer)
osc.bind(b'/cluster', printer)
osc.bind(b"/mob_speed", printer)
sleep(1000)
osc.stop()
return True
def start_osc(self):
global osc
def callback(*values):
print("<<<<<<>>>>>> got values: {}".format(values))
print("STARTING OSC SERVER>>>>>>>>>>>>>>>>>")
osc = OSCThreadServer()
sock = osc.listen(address='0.0.0.0', port=8888, default=True)
osc.bind(b'/address', callback)
def test_bind_address():
osc = OSCThreadServer()
osc.listen(default=True)
result = []
@osc.address(b'/test')
def success(*args):
result.append(True)
timeout = time() + 1
send_message(b'/test', [], *osc.getaddress())
while len(result) < 1:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
sleep(10e-9)
assert True in result
def test_encoding_receive():
osc = OSCThreadServer(encoding='utf8')
osc.listen(default=True)
values = []
@osc.address(u'/encoded')
def encoded(*val):
for v in val:
assert not isinstance(v, bytes)
values.append(val)
send_message(b'/encoded', [b'hello world', u'ééééé ààààà'.encode('utf8')],
*osc.getaddress())
timeout = time() + 2
while not values:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
sleep(10e-9)
class OSC:
"""Ne fait que envoyer avec self.client
et recevoir avec self.server, en com avec service.py
"""
def __init__(self):
self.sensor = "Recherche d'un capteur ..."
# a, b, c, activity, num, tempo
self.display_list = [0, 0, 0, -2, 0, 1, 0]
self.histo = []
self.server = OSCThreadServer()
self.server.listen(address=b'localhost', port=3003, default=True)
self.server.bind(b'/acc', self.on_acc)
self.server.bind(b'/sensor', self.on_sensor)
self.client = OSCClient(b'localhost', 3001)
self.t_init = 0
def on_sensor(self, sens):
"""Vlaleur possible: Andoid Virtual No sensor"""
self.sensor = sens.decode('utf-8')
def on_acc(self, *args):
self.display_list = args
a, b, c, t = (self.display_list[0], self.display_list[1],
self.display_list[2], self.display_list[6])
norme = int((a**2 + b**2 + c**2)**0.5)
# 920736845
# 36845
if self.t_init:
tx = (t - self.t_init) / 100
else:
self.t_init = t
tx = 0
print(tx)
# liste de couple (x, y)
self.histo.append((tx, norme))
if len(self.histo) > 100:
del self.histo[0]
def test_get_sender():
osc = OSCThreadServer(encoding='utf8')
osc.listen(default=True)
values = []
@osc.address(u'/test_route')
def callback(*val):
values.append(osc.get_sender())
with pytest.raises(RuntimeError,
match='get_sender\(\) not called from a callback'):
osc.get_sender()
send_message(b'/test_route', [osc.getaddress()[1]],
*osc.getaddress(),
encoding='utf8')
timeout = time() + 2
while not values:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
sleep(10e-9)
class ctrlOSC(object):
def __init__(self):
super(ctrlOSC, self).__init__()
# self.isrunning = True
self.osc = OSCThreadServer()
self.sock = self.osc.listen(address='0.0.0.0', port=8000, default=True)
self.osc.bind(b'/address', self.callback)
# def run(self):
# while self.isrunning:
# @osc.address(b'/address')
def callback(self, values, *args):
print("got values: {}, {}, {}".format(type(values), values, args))
def test_get_version():
osc = OSCThreadServer(encoding='utf8')
osc.listen(default=True)
values = []
@osc.address(u'/_oscpy/version/answer')
def cb(val):
print(val)
values.append(val)
send_message(b'/_oscpy/version', [osc.getaddress()[1]],
*osc.getaddress(),
encoding='utf8',
encoding_errors='strict')
timeout = time() + 2
while not values:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
sleep(10e-9)
assert __version__ in values
def test_reuse_callback():
osc = OSCThreadServer()
sock = osc.listen()
port = sock.getsockname()[1]
cont = []
def success(*values):
cont.append(True)
osc.bind(b'/success', success, sock)
osc.bind(b'/success', success, sock)
osc.bind(b'/success2', success, sock)
assert len(osc.addresses.get((sock, b'/success'))) == 1
assert len(osc.addresses.get((sock, b'/success2'))) == 1
def test_bind_address_class():
osc = OSCThreadServer()
osc.listen(default=True)
@ServerClass
class Test(object):
def __init__(self):
self.result = []
@osc.address_method(b'/test')
def success(self, *args):
self.result.append(True)
timeout = time() + 1
test = Test()
send_message(b'/test', [], *osc.getaddress())
while len(test.result) < 1:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
sleep(10e-9)
assert True in test.result
def test_intercept_errors(caplog):
cont = []
def success(*values):
cont.append(True)
def broken_callback(*values):
raise ValueError("some bad value")
osc = OSCThreadServer()
sock = osc.listen()
port = sock.getsockname()[1]
osc.bind(b'/broken_callback', broken_callback, sock)
osc.bind(b'/success', success, sock)
send_message(b'/broken_callback', [b'test'], 'localhost', port)
sleep(0.01)
send_message(b'/success', [b'test'], 'localhost', port)
assert not osc.join_server(timeout=0.02) # Thread not stopped
assert cont == [True]
assert len(caplog.records) == 1, caplog.records
record = caplog.records[0]
assert record.msg == "Unhandled exception caught in oscpy server"
assert not record.args
assert record.exc_info
osc = OSCThreadServer(intercept_errors=False)
sock = osc.listen()
port = sock.getsockname()[1]
osc.bind(b'/broken_callback', broken_callback, sock)
send_message(b'/broken_callback', [b'test'], 'localhost', port)
assert osc.join_server(
timeout=0.02) # Thread properly sets termination event on crash
assert len(caplog.records) == 1, caplog.records # Unchanged
def test_send_message():
osc = OSCThreadServer()
sock = osc.listen()
port = sock.getsockname()[1]
acc = []
def success(*values):
acc.append(values[0])
osc.bind(b'/success', success, sock)
timeout = time() + 5
while len(acc) < 100:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
send_message(b'/success', [1], 'localhost', port)
CLIENT = OSCClient('localhost', 3002)
def ping(*_):
'answer to ping messages'
CLIENT.send_message(
b'/message',
[
''.join(sample(ascii_letters, randint(10, 20)))
.encode('utf8'),
],
)
def send_date():
'send date to the application'
CLIENT.send_message(
b'/date',
[asctime(localtime()).encode('utf8'), ],
)
if __name__ == '__main__':
SERVER = OSCThreadServer()
SERVER.listen('localhost', port=3000, default=True)
SERVER.bind(b'/ping', ping)
while True:
sleep(1)
send_date()
