def test_encoding_send_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(u'/encoded', ['hello world', u'ééééé ààààà'],
*osc.getaddress(),
encoding='utf8')
timeout = time() + 2
while not values:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
sleep(10e-9)
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 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 test_terminate_server():
osc = OSCThreadServer()
assert not osc.join_server(timeout=0.1)
assert osc._thread.is_alive()
osc.terminate_server()
assert osc.join_server(timeout=0.1)
assert not osc._thread.is_alive()
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 __init__(self,
osc_port,
osc_client_host,
osc_client_port,
host,
port,
password=''):
self.client = obsws(host, port, password)
self.register_callbacks()
self.osc = OSCThreadServer(
encoding='utf8',
advanced_matching=True,
)
self.socket = None
self.osc_client_host = osc_client_host
self.osc_client_port = osc_client_port
self.osc_port = osc_port
self.volume_changed = False
self.levels = [0, 0]
self.scenes = []
def start(self):
'''Start the TUIO provider'''
try:
from oscpy.server import OSCThreadServer
except ImportError:
Logger.info(
'Please install the oscpy python module to use the TUIO '
'provider.')
raise
self.oscid = osc = OSCThreadServer()
osc.listen(self.ip, self.port, default=True)
for oscpath in TuioMotionEventProvider.__handlers__:
self.touches[oscpath] = {}
osc.bind(oscpath, partial(self._osc_tuio_cb, oscpath))
def test_decorator():
osc = OSCThreadServer()
sock = osc.listen(default=True)
port = sock.getsockname()[1]
cont = []
@osc.address(b'/test1', sock)
def test1(*values):
print("test1 called")
cont.append(True)
@osc.address(b'/test2')
def test2(*values):
print("test1 called")
cont.append(True)
send_message(b'/test1', [], 'localhost', port)
send_message(b'/test2', [], 'localhost', port)
timeout = time() + 1
while len(cont) < 2:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
def test_unbind():
osc = OSCThreadServer()
sock = osc.listen()
port = sock.getsockname()[1]
cont = []
def failure(*values):
cont.append(True)
osc.bind(b'/failure', failure, sock)
with pytest.raises(RuntimeError) as e_info: # noqa
osc.unbind(b'/failure', failure)
osc.unbind(b'/failure', failure, sock)
send_message(b'/failure', [b'test', 1, 1.12345], 'localhost', port)
timeout = time() + 1
while time() > timeout:
assert not cont
sleep(10e-9)
def test_socket_family():
osc = OSCThreadServer()
assert osc.listen().family == socket.AF_INET
filename = mktemp()
if platform != 'win32':
assert osc.listen(address=filename,
family='unix').family == socket.AF_UNIX # noqa
else:
with pytest.raises(AttributeError) as e_info:
osc.listen(address=filename, family='unix')
if exists(filename):
unlink(filename)
with pytest.raises(ValueError) as e_info: # noqa
osc.listen(family='')
def create_server(self):
self.stop()
self.reset_data()
# Fix [Errno 98] Address already in use
sleep(0.01)
self.server = OSCThreadServer(encoding='utf8')
self.server.listen(address='0.0.0.0', port=self._port, default=True)
for address, cb in self._bind_collection.items():
self.server.bind(address, cb)
self.server.bind('/identify_me', self._identify_me)
self._time = str(datetime.now())
try:
self._scan_client.send_message('/identify_me', [self._time])
except OSError:
Logger.exception('P2P: No network')
self.server.unbind('/identify_me', self._identify_me)
return
self.dispatch('on_create_server', self.server)
self.is_running = True
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 on_start(self, **args):
"stuff"
self.current_screen = 'connect'
self.osc_server = server = OSCThreadServer()
self.osc_server.listen(address='0.0.0.0', port=PORT, default=True)
server.bind(b'/found', callback=self.found)
server.bind(b'/conf', callback=self.conf)
sock = socket(AF_INET, SOCK_DGRAM)
sock.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
sock.settimeout(1)
self.scan_client = OSCClient(
address='255.255.255.255',
port=PEER_PORT,
sock=sock,
)
def build(self):
self.service = None
self.server = server = OSCThreadServer()
server.listen(
address=b'localhost',
port=3002,
default=True,
)
server.bind(b'/message', self.display_message)
server.bind(b'/date', self.date)
self.client = OSCClient(b'localhost', 3000)
self.root = Builder.load_string(KV)
return self.root
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_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 test_unbind_default():
osc = OSCThreadServer()
sock = osc.listen(default=True)
port = sock.getsockname()[1]
cont = []
def failure(*values):
cont.append(True)
osc.bind(b'/failure', failure)
osc.unbind(b'/failure', failure)
send_message(b'/failure', [b'test', 1, 1.12345], 'localhost', port)
timeout = time() + 1
while time() > timeout:
assert not cont
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 = "\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_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)
def get_osc_server(is_master=True):
"""
Get the OSC server for the app (master) or service (slave)
"""
server = OSCThreadServer(
encoding="utf8",
default_handler=_osc_default_handler) # This launches a DAEMON thread!
socket_index = 0 if is_master else 1
socket_name = "application" if is_master else "service"
socket_options = _get_osc_socket_options(socket_index=socket_index)
def starter_callback():
logger.info("Binding OSC server of %s process to socket %s" %
(socket_name, socket_options))
if socket_options["family"] == "unix":
socket_file = Path(socket_options["address"])
if socket_file.exists():
socket_file.unlink(
) # Else "Address already in use" error occurs when listening!
server.listen(default=True, **socket_options)
return server, starter_callback
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_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 save_blemote_port_in(self, context):
upd_settings_sub(21)
#bpy.ops.addroutes.refresh_blemote()
def save_blemote_addr_out(self, context):
upd_settings_sub(22)
def save_blemote_port_out(self, context):
upd_settings_sub(23)
blem_server = OSCThreadServer(encoding='utf8',
default_handler=Blemote_callback)
def redraw_hack():
# trick to update the GUI
for window in bpy.context.window_manager.windows:
screen = window.screen
for area in screen.areas:
if area.type == 'VIEW_3D':
area.tag_redraw()
def retry_server():
global blem_server, bl_ok
pref = bpy.context.preferences.addons['AddRoutes'].preferences
bcw = bpy.context.window_manager
print("#" * 80)
print("sending/receiving test")
# address, port = osc.getaddress()
received = 0
def count(*values):
"""Count calls."""
global received
received += 1
for family in 'unix', 'inet':
osc = OSCThreadServer()
print(f"family: {family}")
if family == 'unix':
address, port = '/tmp/test_sock', 0
if os.path.exists(address):
os.unlink(address)
sock = SOCK = osc.listen(address=address, family='unix')
else:
SOCK = sock = osc.listen()
address, port = osc.getaddress(sock)
osc.bind(b'/count', count, sock=sock)
for i, pattern in enumerate(patterns):
for safer in (False, True):
timeout = time() + DURATION
sent = 0
def test_send_message_without_socket():
osc = OSCThreadServer()
with pytest.raises(RuntimeError):
osc.send_message(b'/test', [], 'localhost', 0)
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 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
sleep(.1)
osc.listen(address=host, port=port)
assert len(osc.sockets) == 1
osc.stop_all()
def test_stop_default():
osc = OSCThreadServer()
osc.listen(default=True)
assert len(osc.sockets) == 1
osc.stop()
assert len(osc.sockets) == 0
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()
def test_stop_unknown():
osc = OSCThreadServer()
with pytest.raises(RuntimeError):
osc.stop(socket.socket())
def test_answer():
cont = []
osc_1 = OSCThreadServer()
osc_1.listen(default=True)
@osc_1.address(b'/ping')
def ping(*values):
if True in values:
osc_1.answer(b'/zap', [True], port=osc_3.getaddress()[1])
else:
osc_1.answer(bundle=[(b'/pong', [])])
osc_2 = OSCThreadServer()
osc_2.listen(default=True)
@osc_2.address(b'/pong')
def pong(*values):
osc_2.answer(b'/ping', [True])
osc_3 = OSCThreadServer()
osc_3.listen(default=True)
@osc_3.address(b'/zap')
def zap(*values):
if True in values:
cont.append(True)
osc_2.send_message(b'/ping', [], *osc_1.getaddress())
with pytest.raises(RuntimeError) as e_info: # noqa
osc_1.answer(b'/bing', [])
timeout = time() + 2
while not cont:
if time() > timeout:
raise OSError('timeout while waiting for success message.')
sleep(10e-9)
