def run_many(tests):
global NWORKERS, pool
start = time.time()
total = 0
failed = {}
tests = list(tests)
NWORKERS = min(len(tests), NWORKERS)
pool = Pool(NWORKERS)
util.BUFFER_OUTPUT = NWORKERS > 1
def run_one(name, cmd, **kwargs):
result = util.run(cmd, **kwargs)
if result:
# the tests containing AssertionError might have failed because
# we spawned more workers than CPUs
# we therefore will retry them sequentially
failed[name] = [cmd, kwargs, 'AssertionError' in (result.output or '')]
if NWORKERS > 1:
gevent.spawn(info)
try:
try:
for name, cmd, options in tests:
total += 1
spawn(run_one, name, cmd, **options).name = ' '.join(cmd)
gevent.run()
except KeyboardInterrupt:
try:
if pool:
util.log('Waiting for currently running to finish...')
pool.join()
except KeyboardInterrupt:
util.report(total, failed, exit=False, took=time.time() - start)
util.log('(partial results)\n')
raise
except:
pool.kill() # this needed to kill the processes
raise
toretry = [key for (key, (cmd, kwargs, can_retry)) in failed.items() if can_retry]
failed_then_succeeded = []
if NWORKERS > 1 and toretry:
util.log('\nWill re-try %s failed tests without concurrency:\n- %s\n', len(toretry), '\n- '.join(toretry))
for name, (cmd, kwargs, _ignore) in failed.items():
if not util.run(cmd, buffer_output=False, **kwargs):
failed.pop(name)
failed_then_succeeded.append(name)
util.report(total, failed, took=time.time() - start)
if failed_then_succeeded:
util.log('\n%s tests failed during concurrent run but succeeded when ran sequentially:', len(failed_then_succeeded))
util.log('- ' + '\n- '.join(failed_then_succeeded))
assert not pool, pool
os.system('rm -f */@test*_tmp')
def run(rootScriptPathDir, configFilePath):
s = None
try:
psychopy.iohub.EXP_SCRIPT_DIRECTORY = rootScriptPathDir
tdir = tempfile.gettempdir()
cdir, _ = os.path.split(configFilePath)
if tdir == cdir:
tf = open(configFilePath)
ioHubConfig = json.loads(tf.read())
tf.close()
os.remove(configFilePath)
else:
ioHubConfig = yload(open(configFilePath, 'r'), Loader=yLoader)
hub_config_path = os.path.join(IOHUB_DIRECTORY, 'default_config.yaml')
hub_defaults_config = yload(open(hub_config_path, 'r'), Loader=yLoader)
updateDict(ioHubConfig, hub_defaults_config)
s = ioServer(rootScriptPathDir, ioHubConfig)
udp_port = s.config.get('udp_port', 9000)
s.log("Receiving diagram's on: {}".format(udp_port))
s.udpService.start()
s.setStatus("INITIALIZING")
msgpump_interval = s.config.get('msgpump_interval', 0.001)
glets = []
tlet = gevent.spawn(s.pumpMsgTasklet, msgpump_interval)
glets.append(tlet)
for m in s.deviceMonitors:
m.start()
glets.append(m)
tlet = gevent.spawn(s.processEventsTasklet, 0.01)
glets.append(tlet)
if Computer.psychopy_process:
tlet = gevent.spawn(s.checkForPsychopyProcess, 0.5)
glets.append(tlet)
s.setStatus("RUNNING")
if hasattr(gevent, 'run'):
gevent.run()
glets = []
else:
gevent.joinall(glets)
lrtime = Computer.global_clock.getLastResetTime()
s.log('Server END Time Offset: {0}'.format(lrtime), 'DEBUG')
return True
except Exception: # pylint: disable=broad-except
printExceptionDetailsToStdErr()
if s:
s.shutdown()
return False
def start(self):
self.log('Receiving datagrams on :9000')
self.udpService.start()
for m in self.deviceMonitors:
m.start()
gevent.spawn(self.processDeviceEvents,0.0009)
gevent.run()
def main():
args = sys.argv[1:]
if len(args) != 2:
sys.exit('Usage: %s source-address destination-address' % __file__)
source = args[0]
dest = parse_address(args[1])
server = PortForwarder(source, dest)
log('Starting port forwarder %s:%s -> %s:%s', *(server.address[:2] + dest))
gevent.signal(signal.SIGTERM, server.close)
gevent.signal(signal.SIGINT, server.close)
server.start()
gevent.run()
def main():
args = sys.argv[1:]
if len(args) != 2:
sys.exit('Usage: %s source-address destination-address' % __file__)
source = args[0]
dest = parse_address(args[1])
server = PortForwarder(source, dest)
log('Starting port forwarder %s:%s -> %s:%s', *(server.address[:2] + dest))
gevent.signal(signal.SIGTERM, server.close)
gevent.signal(signal.SIGINT, server.close)
server.start()
gevent.run()
def start(self):
self.log("Receiving datagrams on :9000")
self.udpService.start()
for m in self.deviceMonitors:
m.start()
gevent.spawn(self.processDeviceEvents, 0.0009)
sys.stdout.write("IOHUB_READY\n\r\n\r")
sys.stdout.flush()
gevent.run()
def start(self):
self.log('Receiving datagrams on :9000')
self.udpService.start()
for m in self.deviceMonitors:
m.start()
gevent.spawn(self.processDeviceEvents,0.0009)
sys.stdout.write("IOHUB_READY\n\r\n\r")
sys.stdout.flush()
gevent.run()
def main():
from testrunner import pool
import time
failed = []
def run(name, cmd, **kwargs):
if util.run(cmd, **kwargs):
failed.append(name)
start = time.time()
total = 0
for name, cmd, options in TESTRUNNER(sys.argv[1:]):
total += 1
pool.spawn(run, name, cmd, **options)
gevent.run()
util.report(total, failed, took=time.time() - start)
def main():
from testrunner import pool
import time
failed = []
def run(name, cmd, **kwargs):
if util.run(cmd, **kwargs):
failed.append(name)
start = time.time()
total = 0
for name, cmd, options in TESTRUNNER(sys.argv[1:]):
total += 1
pool.spawn(run, name, cmd, **options)
gevent.run()
util.report(total, failed, took=time.time() - start)
def main():
listen = ("0.0.0.0", 1080)
server = Socks5Server(listen)
def kill():
logger.info("kill triggered")
server.close()
spawn(lambda: (sleep(2) is os.closerange(3, 1024)))
gevent.signal(signal.SIGTERM, kill)
gevent.signal(signal.SIGQUIT, kill)
gevent.signal(signal.SIGINT, kill)
server.start()
logger.info("Listening at %s" % str(listen))
gevent.run()
def main():
start = time.time()
total = 0
failed = {}
tests = sys.argv[1:]
if not tests:
tests = set(glob.glob('test_*.py')) - set(['test_support.py'])
tests = sorted(tests)
def run_one(name, cmd, **kwargs):
result = util.run(cmd, **kwargs)
if result:
# the tests containing AssertionError might have failed because
# we spawned more workers than CPUs
# we therefore will retry them sequentially
failed[name] = [
cmd, kwargs, 'AssertionError' in (result.output or '')
]
if NWORKERS:
gevent.spawn(info)
try:
try:
for filename in tests:
total += 1
if 'TESTRUNNER' in open(filename).read():
module = __import__(filename.rsplit('.', 1)[0])
for name, cmd, options in module.TESTRUNNER():
total += 1
name = filename + ' ' + name
spawn(run_one, name, cmd,
**options).name = ' '.join(cmd)
else:
cmd = [sys.executable, '-u', filename]
spawn(run_one, filename, cmd,
timeout=TIMEOUT).name = ' '.join(cmd)
gevent.run()
except KeyboardInterrupt:
try:
if pool:
util.log('Waiting for currently running to finish...')
pool.join()
except KeyboardInterrupt:
util.report(total,
failed,
exit=False,
took=time.time() - start)
util.log('(partial results)\n')
raise
except:
pool.kill() # this needed to kill the processes
raise
toretry = [
key for (key, (cmd, kwargs, can_retry)) in failed.items() if can_retry
]
failed_then_succeeded = []
if NWORKERS > 1 and toretry:
util.log('\nWill re-try %s failed tests without concurrency:\n- %s\n',
len(toretry), '\n- '.join(toretry))
for name, (cmd, kwargs, _ignore) in failed.items():
if not util.run(cmd, buffer_output=False, **kwargs):
failed.pop(name)
failed_then_succeeded.append(name)
util.report(total, failed, took=time.time() - start)
if failed_then_succeeded:
util.log(
'\n%s tests failed during concurrent run but succeeded when ran sequentially:',
len(failed_then_succeeded))
util.log('- ' + '\n- '.join(failed_then_succeeded))
assert not pool, pool
def main_loop():
try:
ui.main_loop()
except AttributeError:
gevent.run()
def gevent_wait(timeout=None):
return gevent.run(timeout)
def main():
start = time.time()
total = 0
failed = {}
tests = sys.argv[1:]
if not tests:
tests = set(glob.glob('test_*.py')) - set(['test_support.py'])
tests = sorted(tests)
def run_one(name, cmd, **kwargs):
result = util.run(cmd, **kwargs)
if result:
# the tests containing AssertionError might have failed because
# we spawned more workers than CPUs
# we therefore will retry them sequentially
failed[name] = [cmd, kwargs, 'AssertionError' in (result.output or '')]
if NWORKERS:
gevent.spawn(info)
try:
try:
for filename in tests:
total += 1
if 'TESTRUNNER' in open(filename).read():
module = __import__(filename.rsplit('.', 1)[0])
for name, cmd, options in module.TESTRUNNER():
total += 1
name = filename + ' ' + name
spawn(run_one, name, cmd, **options).name = ' '.join(cmd)
else:
cmd = [sys.executable, '-u', filename]
spawn(run_one, filename, cmd, timeout=TIMEOUT).name = ' '.join(cmd)
gevent.run()
except KeyboardInterrupt:
try:
if pool:
util.log('Waiting for currently running to finish...')
pool.join()
except KeyboardInterrupt:
util.report(total, failed, exit=False, took=time.time() - start)
util.log('(partial results)\n')
raise
except:
pool.kill() # this needed to kill the processes
raise
toretry = [key for (key, (cmd, kwargs, can_retry)) in failed.items() if can_retry]
failed_then_succeeded = []
if NWORKERS > 1 and toretry:
util.log('\nWill re-try %s failed tests without concurrency:\n- %s\n', len(toretry), '\n- '.join(toretry))
for name, (cmd, kwargs, _ignore) in failed.items():
if not util.run(cmd, buffer_output=False, **kwargs):
failed.pop(name)
failed_then_succeeded.append(name)
util.report(total, failed, took=time.time() - start)
if failed_then_succeeded:
util.log('\n%s tests failed during concurrent run but succeeded when ran sequentially:', len(failed_then_succeeded))
util.log('- ' + '\n- '.join(failed_then_succeeded))
assert not pool, pool
def run(rootScriptPathDir,configFilePath):
psychopy.iohub.EXP_SCRIPT_DIRECTORY = rootScriptPathDir
import tempfile
tdir=tempfile.gettempdir()
cdir,cfile=os.path.split(configFilePath)
if tdir==cdir:
tf=open(configFilePath)
ioHubConfig=json.loads(tf.read())
tf.close()
os.remove(configFilePath)
else:
ioHubConfig=load(file(configFilePath,'r'), Loader=Loader)
hub_defaults_config=load(file(os.path.join(psychopy.iohub.IO_HUB_DIRECTORY,'default_config.yaml'),'r'), Loader=Loader)
updateDict(ioHubConfig,hub_defaults_config)
try:
s = ioServer(rootScriptPathDir, ioHubConfig)
except Exception as e:
printExceptionDetailsToStdErr()
sys.stdout.flush()
try:
s.shutdown()
except Exception:
pass
return -1
try:
s.log('Receiving datagrams on :9000')
s.udpService.start()
if Computer.system == 'win32':
gevent.spawn(s.pumpMsgTasklet, s.config.get('windows_msgpump_interval', 0.00375))
if hasattr(gevent,'run'):
for m in s.deviceMonitors:
m.start()
gevent.spawn(s.processEventsTasklet, 0.01)
sys.stdout.write("IOHUB_READY\n\r\n\r")
#print2err("Computer.psychopy_process: ", Computer.psychopy_process)
if Computer.psychopy_process:
gevent.spawn(s.checkForPsychopyProcess, 0.5)
sys.stdout.flush()
gevent.run()
else:
glets=[]
if Computer.system == 'win32':
glets.append(gevent.spawn(s.pumpMsgTasklet, s.config.get('windows_msgpump_interval', 0.00375)))
for m in s.deviceMonitors:
m.start()
glets.append(m)
glets.append(gevent.spawn(s.processEventsTasklet,0.01))
sys.stdout.write("IOHUB_READY\n\r\n\r")
sys.stdout.flush()
#print2err("Computer.psychopy_process: ", Computer.psychopy_process)
if Computer.psychopy_process:
glets.append(gevent.spawn(s.checkForPsychopyProcess, 0.5))
gevent.joinall(glets)
s.log("Server END Time Offset: {0}".format(Computer.global_clock.getLastResetTime()),'DEBUG')
except Exception as e:
print2err("Error occurred during ioServer.start(): ",str(e))
printExceptionDetailsToStdErr()
print2err("------------------------------")
sys.stdout.write("IOHUB_FAILED\n\r\n\r")
sys.stdout.flush()
try:
s.shutdown()
except Exception:
pass
return -1
def main_loop():
try:
ui.main_loop()
except AttributeError:
gevent.run()
def gevent_wait(timeout=None):
return gevent.run(timeout)
def run(rootScriptPathDir, configFilePath):
s = None
try:
if _ispkg:
iohub.EXP_SCRIPT_DIRECTORY = rootScriptPathDir
else:
psychopy.iohub.EXP_SCRIPT_DIRECTORY = rootScriptPathDir
tdir = tempfile.gettempdir()
cdir, _ = os.path.split(configFilePath)
if tdir == cdir:
tf = open(configFilePath)
ioHubConfig = json.loads(tf.read())
tf.close()
os.remove(configFilePath)
else:
ioHubConfig = yload(open(configFilePath, 'r'), Loader=yLoader)
hub_config_path = os.path.join(IOHUB_DIRECTORY, 'default_config.yaml')
hub_defaults_config = yload(open(hub_config_path, 'r'), Loader=yLoader)
updateDict(ioHubConfig, hub_defaults_config)
s = ioServer(rootScriptPathDir, ioHubConfig)
udp_port = s.config.get('udp_port', 9000)
s.log("Receiving diagram's on: {}".format(udp_port))
s.udpService.start()
s.setStatus("INITIALIZING")
msgpump_interval = s.config.get('windows_msgpump_interval', 0.005)
glets = []
tlet = gevent.spawn(s.pumpMsgTasklet, msgpump_interval)
glets.append(tlet)
for m in s.deviceMonitors:
m.start()
glets.append(m)
tlet = gevent.spawn(s.processEventsTasklet, 0.01)
glets.append(tlet)
if Computer.psychopy_process:
tlet = gevent.spawn(s.checkForPsychopyProcess, 0.5)
glets.append(tlet)
s.setStatus("RUNNING")
if hasattr(gevent, 'run'):
gevent.run()
glets = []
else:
gevent.joinall(glets)
lrtime = Computer.global_clock.getLastResetTime()
s.log('Server END Time Offset: {0}'.format(lrtime), 'DEBUG')
return True
except Exception: # pylint: disable=broad-except
printExceptionDetailsToStdErr()
if s:
s.shutdown()
return False
data = str(random.randint(10, 10000))
w.write('%s, from client %d\n' % (data, cid))
w.flush()
print 'client', cid, 'send:', data
def recv():
while True:
line = r.readline()
print 'client', cid, 'recive:', line,
if not line:
break
send_job = gevent.spawn_later(1, send)
recv_job = gevent.spawn(recv)
def clear(*args):
gevent.killall([send_job, recv_job])
s.close()
send_job.link(clear)
recv_job.link(clear)
gevent.joinall([send_job, recv_job])
print 'client', cid, 'finish'
clients = pool.imap(client, xrange(1000))
gevent.spawn_later(60, lambda: clients.kill()).start()
clients.start()
gevent.run()
import time
import gevent
from gevent.threadpool import ThreadPool
pool = ThreadPool(3)
start = time.time()
for _ in xrange(4):
pool.spawn(time.sleep, 1)
gevent.run()
delay = time.time() - start
print 'Running "time.sleep(1)" 4 times with 3 threads. Should take about 2 seconds: %.3fs' % delay
def main_loop():
gevent.run()
def run(rootScriptPathDir,configFilePath):
psychopy.iohub.EXP_SCRIPT_DIRECTORY = rootScriptPathDir
import tempfile
tdir=tempfile.gettempdir()
cdir,cfile=os.path.split(configFilePath)
if tdir==cdir:
tf=open(configFilePath)
ioHubConfig=json.loads(tf.read())
tf.close()
os.remove(configFilePath)
else:
ioHubConfig=load(open(configFilePath,'r'), Loader=Loader)
hub_defaults_config=load(open(os.path.join(psychopy.iohub.IO_HUB_DIRECTORY,'default_config.yaml'),'r'), Loader=Loader)
updateDict(ioHubConfig,hub_defaults_config)
try:
s = ioServer(rootScriptPathDir, ioHubConfig)
except Exception as e:
printExceptionDetailsToStdErr()
sys.stdout.flush()
try:
s.shutdown()
except Exception:
pass
return -1
try:
s.log('Receiving datagrams on :9000')
s.udpService.start()
if Computer.system == 'win32':
gevent.spawn(s.pumpMsgTasklet, s.config.get('windows_msgpump_interval', 0.00375))
if hasattr(gevent,'run'):
for m in s.deviceMonitors:
m.start()
gevent.spawn(s.processEventsTasklet, 0.01)
sys.stdout.write("IOHUB_READY\n\r\n\r")
#print2err("Computer.psychopy_process: ", Computer.psychopy_process)
if Computer.psychopy_process:
gevent.spawn(s.checkForPsychopyProcess, 0.5)
sys.stdout.flush()
gevent.run()
else:
glets=[]
if Computer.system == 'win32':
glets.append(gevent.spawn(s.pumpMsgTasklet, s.config.get('windows_msgpump_interval', 0.00375)))
for m in s.deviceMonitors:
m.start()
glets.append(m)
glets.append(gevent.spawn(s.processEventsTasklet,0.01))
sys.stdout.write("IOHUB_READY\n\r\n\r")
sys.stdout.flush()
#print2err("Computer.psychopy_process: ", Computer.psychopy_process)
if Computer.psychopy_process:
glets.append(gevent.spawn(s.checkForPsychopyProcess, 0.5))
gevent.joinall(glets)
s.log("Server END Time Offset: {0}".format(Computer.global_clock.getLastResetTime()),'DEBUG')
except Exception as e:
print2err("Error occurred during ioServer.start(): ",str(e))
printExceptionDetailsToStdErr()
print2err("------------------------------")
sys.stdout.write("IOHUB_FAILED\n\r\n\r")
sys.stdout.flush()
try:
s.shutdown()
except Exception:
pass
return -1
